granicus.if.org Git - zziplib/blob - test/zziptests.py

   1 import unittest
   2 import subprocess
   3 import logging
   4 import inspect
   5 import os
   6 import collections
   7 import urllib
   8 import shutil
   9 import random
  10 import re
  11 from fnmatch import fnmatchcase as matches
  12 from cStringIO import StringIO
  13
  14 logg = logging.getLogger("test")
  15
  16 topsrcdir = "../.."
  17 testdatadir = "testdata.d"
  18 readme = "README"
  19 mkzip = "zip"
  20 unzip = "unzip"
  21 exeext = ""
  22
  23 def shell_string(command):
  24    return " ".join(["'%s'" % arg.replace("'","\\'") for arg in command])
  25
  26 def shell(command, shell=True, calls=False, cwd=None, env=None, lang=None, returncodes=None):
  27     returncodes = returncodes or [ None, 0 ]
  28     Shell = collections.namedtuple("Shell",["returncode", "output", "errors", "shell"])
  29     if isinstance(command, basestring):
  30        sh_command = command
  31        command = [ command ]
  32     else:
  33        sh_command = shell_string(command)
  34     if not env:
  35         env = os.environ.copy()
  36     if lang:
  37         for name, value in env.items():
  38             if name.startswith("LC_"):
  39                 env[name] = lang
  40         env["LANG"] = lang # defines message format
  41         env["LC_ALL"] = lang # other locale formats
  42     build_libs = os.path.dirname(os.path.dirname(os.path.realpath(command[0])))+"/zzip/.libs"
  43     if os.path.isdir(build_libs):
  44         env["LD_LIBRARY_PATH"] = build_libs
  45     try:
  46         output, errors = "", ""
  47         if calls:
  48             logg.debug("result from %s: %s", cwd and cwd+"/" or "shell", sh_command)
  49             run = subprocess.Popen(command, shell=shell, cwd=cwd, env=env)
  50             if run.returncode:
  51                 logg.warning("EXIT %s: %s", run.returncode, command)
  52             run.wait()
  53         else:
  54             logg.debug("output from %s: %s", cwd and cwd+"/" or "shell", sh_command)
  55             run = subprocess.Popen(command, shell=shell, cwd=cwd,
  56                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None, env=env)
  57             if run.returncode:
  58                 logg.warning("EXIT %s: %s", run.returncode, command)
  59             output, errors = run.communicate() # run.wait()
  60     except:
  61         logg.error("*E*: %s", sh_command)
  62         for line in output.split("\n"):
  63             if line:
  64                 logg.error("OUT: %s", line)
  65         for line in errors.split("\n"):
  66             if line:
  67                 logg.error("ERR: %s", line)
  68         raise
  69     if run.returncode not in returncodes:
  70         logg.warning("*%02i: %s", run.returncode, sh_command)
  71         for line in output.split("\n"):
  72             if line:
  73                 logg.warning("OUT: %s", line)
  74         for line in errors.split("\n"):
  75             if line:
  76                 logg.warning("ERR: %s", line)
  77         raise subprocess.CalledProcessError(run.returncode, sh_command, output)
  78     else:
  79         for line in output.split("\n"):
  80             if line:
  81                 logg.debug("OUT: %s", line)
  82         for line in errors.split("\n"):
  83             if line:
  84                 logg.debug("ERR: %s", line)
  85     return Shell(run.returncode, output, errors, sh_command)
  86
  87 def get_caller_name():
  88     frame = inspect.currentframe().f_back.f_back
  89     return frame.f_code.co_name
  90 def get_caller_caller_name():
  91     frame = inspect.currentframe().f_back.f_back.f_back
  92     return frame.f_code.co_name
  93
  94 def download(base_url, filename, into):
  95     data = "tmp.download"
  96     if not os.path.isdir(data):
  97         os.makedirs(data)
  98     subname = urllib.quote_plus(base_url)
  99     subdir = os.path.join(data, subname)
 100     if not os.path.isdir(subdir):
 101         os.makedirs(subdir)
 102     subfile = os.path.join(subdir, filename)
 103     if not os.path.exists(subfile):
 104        logg.info("need %s", subfile)
 105        d = urllib.urlopen(base_url + "/" + filename)
 106        f = open(subfile, "w")
 107        f.write(d.read())
 108        f.close()
 109     #
 110     if not os.path.isdir(into):
 111         os.makedirs(into)
 112     shutil.copy(subfile, into)
 113     return filename
 114
 115 def output(cmd, shell=True):
 116     run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
 117     out, err = run.communicate()
 118     return out
 119 def grep(pattern, lines):
 120     if isinstance(lines, basestring):
 121         lines = lines.split("\n")
 122     for line in lines:
 123        if re.search(pattern, line.rstrip()):
 124            yield line.rstrip()
 125 def greps(lines, pattern):
 126     return list(grep(pattern, lines))
 127 def all_errors(lines):
 128     if isinstance(lines, basestring):
 129         lines = lines.split("\n")
 130     for line in lines:
 131         if not line.strip():
 132             continue
 133         if "DEBUG:" in line:
 134             continue
 135         if "HINT:" in line:
 136             continue
 137         yield line.rstrip()
 138 def errors(lines):
 139     return list(all_errors(lines))
 140
 141 class ZZipTest(unittest.TestCase):
 142   @property
 143   def t(self):
 144         if not os.path.isdir(testdatadir):
 145             os.makedirs(testdatadir)
 146         return testdatdir
 147   @property
 148   def s(self):
 149     return topsrcdir
 150   def src(self, name):
 151     return os.path.join(self.s, name)
 152   def readme(self):
 153     f = open(self.src(readme))
 154     text = f.read()
 155     f.close()
 156     return text
 157   def mkfile(self, name, content):
 158     b = os.path.dirname(name)
 159     if not os.path.isdir(b):
 160         os.makedirs(b)
 161     f = open(name, "w")
 162     f.write(content)
 163     f.close()
 164   def bins(self, name):
 165     if name == "unzip": return unzip
 166     if name == "mkzip": return mkzip
 167     exe = os.path.join("..", "bins", name)
 168     if exeext: exe += exeext
 169     return exe
 170   def gentext(self, size):
 171     random.seed(1234567891234567890)
 172     result = StringIO()
 173     old1 = ''
 174     old2 = ''
 175     for i in xrange(size):
 176         while True:
 177             x = random.choice("       abcdefghijklmnopqrstuvwxyz\n")
 178             if x == old1 or x == old2: continue
 179             old1 = old2
 180             old2 = x
 181             break
 182         result.write(x)
 183     return result.getvalue()
 184   def caller_testname(self):
 185     name = get_caller_caller_name()
 186     x1 = name.find("_")
 187     if x1 < 0: return name
 188     x2 = name.find("_", x1+1)
 189     if x2 < 0: return name
 190     return name[:x2]
 191   def testname(self, suffix = None):
 192     name = self.caller_testname()
 193     if suffix:
 194         return name + "_" + suffix
 195     return name
 196   def testzip(self, testname = None):
 197     testname = testname or self.caller_testname()
 198     zipname = testname + ".zip"
 199     return zipname
 200   def testdir(self, testname = None):
 201     testname = testname or self.caller_testname()
 202     newdir = "tmp."+testname
 203     if os.path.isdir(newdir):
 204         shutil.rmtree(newdir)
 205     os.makedirs(newdir)
 206     return newdir
 207   def rm_testdir(self, testname = None):
 208     testname = testname or self.caller_testname()
 209     newdir = "tmp."+testname
 210     if os.path.isdir(newdir):
 211         shutil.rmtree(newdir)
 212     return newdir
 213   def rm_testzip(self, testname = None):
 214     testname = testname or self.caller_testname()
 215     zipname = testname + ".zip"
 216     if os.path.exists(zipname):
 217         os.remove(zipname)
 218     return True
 219   ################################################################
 220   def test_1000_make_test0_zip(self):
 221     """ create a test.zip for later tests using standard 'zip'
 222     It will fall back to a variant in the source code if 'zip'
 223     is not installed on the build host. The content is just
 224     the README file that we can check for equality later on. """
 225     zipfile="test0.zip"
 226     tmpdir="test0.tmp"
 227     exe=self.bins("mkzip")
 228     filename = os.path.join(tmpdir,"README")
 229     filetext = self.readme()
 230     self.mkfile(filename, filetext)
 231     shell("{exe} ../{zipfile} README".format(**locals()), cwd=tmpdir)
 232     self.assertGreater(os.path.getsize(zipfile), 10)
 233   def test_10001_make_test1_zip(self):
 234     """ create a test1.zip for later tests using standard 'zip'
 235     It will fall back to a variant in the source code if 'zip'
 236     is not installed on the build host. The archive has 10
 237     generic files that we can check for their content later. """
 238     zipfile="test1.zip"
 239     tmpdir="test1.tmp"
 240     exe=self.bins("mkzip")
 241     for i in [1,2,3,4,5,6,7,8,9]:
 242        filename = os.path.join(tmpdir,"file.%i" % i)
 243        filetext = "file-%i\n" % i
 244        self.mkfile(filename, filetext)
 245     filename = os.path.join(tmpdir,"README")
 246     filetext = self.readme()
 247     self.mkfile(filename, filetext)
 248     shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir)
 249     self.assertGreater(os.path.getsize(zipfile), 10)
 250   def test_10002_make_test2_zip(self):
 251     """ create a test2.zip for later tests using standard 'zip'
 252     It will NOT fall back to a variant in the source code.
 253     The archive has 100 generic files with known content. """
 254     zipfile="test2.zip"
 255     tmpdir="test2.tmp"
 256     exe=self.bins("mkzip")
 257     for i in xrange(100):
 258        filename = os.path.join(tmpdir,"file.%02i" % i)
 259        filetext = "file-%02i\n" % i
 260        self.mkfile(filename, filetext)
 261     filename = os.path.join(tmpdir,"README")
 262     filetext = self.readme()
 263     self.mkfile(filename, filetext)
 264     shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir)
 265     self.assertGreater(os.path.getsize(zipfile), 10)
 266   def test_10003_make_test3_zip(self):
 267     """ create a test3.zip for later tests using standard 'zip'
 268     It will NOT fall back to a variant in the source code.
 269     The archive has 1000 generic files with known content. """
 270     zipfile="test3.zip"
 271     tmpdir="test3.tmp"
 272     exe=self.bins("mkzip")
 273     for i in xrange(1000):
 274        filename = os.path.join(tmpdir,"file.%03i" % i)
 275        filetext = "file-%03i\n" % i
 276        self.mkfile(filename, filetext)
 277     filename = os.path.join(tmpdir,"README")
 278     filetext = self.readme()
 279     self.mkfile(filename, filetext)
 280     shell("{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir)
 281     self.assertGreater(os.path.getsize(zipfile), 10)
 282   def test_10004_make_test4_zip(self):
 283     """ create a test4.zip for later tests using standard 'zip'
 284     It will NOT fall back to a variant in the source code.
 285     The archive has 10000 generic files with known content
 286     and they are stored (NOT compressed) in the archive. """
 287     zipfile="test4.zip"
 288     tmpdir="test4.tmp"
 289     exe=self.bins("mkzip")
 290     for i in xrange(10000):
 291        filename = os.path.join(tmpdir,"file%04i.txt" % i)
 292        filetext = "file-%04i\n" % i
 293        self.mkfile(filename, filetext)
 294     filename = os.path.join(tmpdir,"README")
 295     filetext = self.readme()
 296     self.mkfile(filename, filetext)
 297     shell("{exe} -n README ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir)
 298     self.assertGreater(os.path.getsize(zipfile), 1000000)
 299   def test_10005_make_test5_zip(self):
 300     """ create a test5.zip for later tests using standard 'zip'
 301     It will NOT fall back to a variant in the source code.
 302     The archive has files at multiple subdirectories depth
 303     and of varying sizes each. """
 304     zipfile="test5.zip"
 305     tmpdir="test5.tmp"
 306     exe=self.bins("mkzip")
 307     for depth in xrange(20):
 308       dirpath = ""
 309       for i in xrange(depth):
 310         if i:
 311           dirpath += "subdir%i/" % i
 312       for size in xrange(18):
 313         size = 2 ** size
 314         filetext = self.gentext(size)
 315         filepart = "file%i-%i.txt" % (depth, size)
 316         filename = os.path.join(tmpdir, dirpath + filepart )
 317         self.mkfile(filename, filetext)
 318     filename = os.path.join(tmpdir,"README")
 319     filetext = self.readme()
 320     self.mkfile(filename, filetext)
 321     shell("{exe} ../{zipfile} -r file* subdir* README".format(**locals()), cwd=tmpdir)
 322     self.assertGreater(os.path.getsize(zipfile), 1000000)
 323   def test_10010_make_test0_dat(self):
 324     """ create test.dat from test.zip with xorcopy """
 325     zipfile = "test0.zip"
 326     datfile = "test0x.dat"
 327     exe = self.bins("zzxorcopy")
 328     shell("{exe} {zipfile} {datfile}".format(**locals()))
 329     self.assertGreater(os.path.getsize(datfile), 10)
 330     self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile))
 331   def test_10011_make_test1_dat(self):
 332     """ create test.dat from test.zip with xorcopy """
 333     zipfile = "test1.zip"
 334     datfile = "test1x.dat"
 335     exe = self.bins("zzxorcopy")
 336     shell("{exe} {zipfile} {datfile}".format(**locals()))
 337     self.assertGreater(os.path.getsize(datfile), 10)
 338     self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile))
 339   def test_10012_make_test2_dat(self):
 340     """ create test.dat from test.zip with xorcopy """
 341     zipfile = "test2.zip"
 342     datfile = "test2x.dat"
 343     exe = self.bins("zzxorcopy")
 344     shell("{exe} {zipfile} {datfile}".format(**locals()))
 345     self.assertGreater(os.path.getsize(datfile), 10)
 346     self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile))
 347   def test_10013_make_test3_dat(self):
 348     """ create test.dat from test.zip with xorcopy """
 349     zipfile = "test3.zip"
 350     datfile = "test3x.dat"
 351     exe = self.bins("zzxorcopy")
 352     shell("{exe} {zipfile} {datfile}".format(**locals()))
 353     self.assertGreater(os.path.getsize(datfile), 10)
 354     self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile))
 355   def test_10014_make_test4_dat(self):
 356     """ create test.dat from test.zip with xorcopy """
 357     zipfile = "test4.zip"
 358     datfile = "test4x.dat"
 359     exe = self.bins("zzxorcopy")
 360     shell("{exe} {zipfile} {datfile}".format(**locals()))
 361     self.assertGreater(os.path.getsize(datfile), 10)
 362     self.assertEqual(os.path.getsize(datfile), os.path.getsize(zipfile))
 363   def test_20000_zziptest_test0_zip(self):
 364     """ run zziptest on test.zip """
 365     zipfile = "test0.zip"
 366     logfile = "test0.log"
 367     exe = self.bins("zziptest")
 368     shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals()))
 369     self.assertGreater(os.path.getsize(logfile), 10)
 370   def test_20001_zziptest_test1_zip(self):
 371     """ run zziptest on test.zip """
 372     zipfile = "test1.zip"
 373     logfile = "test1.log"
 374     exe = self.bins("zziptest")
 375     shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals()))
 376     self.assertGreater(os.path.getsize(logfile), 10)
 377   def test_20002_zziptest_test2_zip(self):
 378     """ run zziptest on test.zip """
 379     zipfile = "test2.zip"
 380     logfile = "test2.log"
 381     exe = self.bins("zziptest")
 382     shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals()))
 383     self.assertGreater(os.path.getsize(logfile), 10)
 384   def test_20003_zziptest_test3_zip(self):
 385     """ run zziptest on test.zip """
 386     zipfile = "test3.zip"
 387     logfile = "test3.log"
 388     exe = self.bins("zziptest")
 389     shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals()))
 390     self.assertGreater(os.path.getsize(logfile), 10)
 391   def test_20004_zziptest_test4_zip(self):
 392     """ run zziptest on test.zip """
 393     zipfile = "test4.zip"
 394     logfile = "test4.log"
 395     exe = self.bins("zziptest")
 396     shell("{exe} --quick {zipfile} | tee {logfile}".format(**locals()))
 397     self.assertGreater(os.path.getsize(logfile), 10)
 398   def test_20010_zzcat_test0_zip(self):
 399     """ run zzcat on test.zip using just test/README """
 400     zipfile = "test0.zip"
 401     getfile = "test0/README"
 402     logfile = "test0.readme.txt"
 403     exe = self.bins("zzcat")
 404     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 405     self.assertGreater(os.path.getsize(logfile), 10)
 406     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 407   def test_20011_zzcat_test1_zip(self):
 408     """ run zzcat on test.zip using just test/README """
 409     zipfile = "test1.zip"
 410     getfile = "test1/README"
 411     logfile = "test1.readme.txt"
 412     exe = self.bins("zzcat")
 413     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 414     self.assertGreater(os.path.getsize(logfile), 10)
 415     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 416     getfile = "test1/file.1"
 417     run = shell("{exe} {getfile}".format(**locals()))
 418     self.assertEqual("file-1\n", run.output)
 419   def test_20012_zzcat_test2_zip(self):
 420     """ run zzcat on test.zip using just test/README """
 421     zipfile = "test2.zip"
 422     getfile = "test2/README"
 423     logfile = "test2.readme.txt"
 424     exe = self.bins("zzcat")
 425     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 426     self.assertGreater(os.path.getsize(logfile), 10)
 427     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 428     getfile = "test2/file.22"
 429     run = shell("{exe} {getfile}".format(**locals()))
 430     self.assertEqual("file-22\n", run.output)
 431   def test_20013_zzcat_test3_zip(self):
 432     """ run zzcat on test.zip using just test/README """
 433     zipfile = "test3.zip"
 434     getfile = "test3/README"
 435     logfile = "test3.readme.txt"
 436     exe = self.bins("zzcat")
 437     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 438     self.assertGreater(os.path.getsize(logfile), 10)
 439     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 440     getfile = "test3/file.999"
 441     run = shell("{exe} {getfile}".format(**locals()))
 442     self.assertEqual("file-999\n", run.output)
 443   def test_20014_zzcat_test4_zip(self):
 444     """ run zzcat on test.zip using just test/README """
 445     zipfile = "test4.zip"
 446     getfile = "test4/README"
 447     logfile = "test4.readme.txt"
 448     exe = self.bins("zzcat")
 449     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 450     self.assertGreater(os.path.getsize(logfile), 10)
 451     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 452     getfile = "test4/file9999.txt"
 453     run = shell("{exe} {getfile}".format(**locals()))
 454     self.assertEqual("file-9999\n", run.output)
 455   def test_20020_zzdir_test0_zip(self):
 456     """ run zzdir on test0.zip using just 'test0' """
 457     zipfile = "test0.zip"
 458     getfile = "test0"
 459     exe = self.bins("zzdir")
 460     run = shell("{exe} {getfile} ".format(**locals()))
 461     self.assertIn(' README\n', run.output)
 462     self.assertIn(' defl:N ', run.output)
 463     self.assertLess(len(run.output), 30)
 464   def test_20021_zzdir_test1_zip(self):
 465     """ run zzdir on test1.zip using just 'test1' """
 466     zipfile = "test1.zip"
 467     getfile = "test1"
 468     exe = self.bins("zzdir")
 469     run = shell("{exe} {getfile} ".format(**locals()))
 470     self.assertIn(' file.1\n', run.output)
 471     self.assertIn(' file.2\n', run.output)
 472     self.assertIn(' file.9\n', run.output)
 473     self.assertIn(' README\n', run.output)
 474     self.assertIn(' defl:N ', run.output)
 475     self.assertIn(' stored ', run.output)
 476   def test_20022_zzdir_test2_zip(self):
 477     """ run zzdir on test2.zip using just 'test2' """
 478     zipfile = "test2.zip"
 479     getfile = "test2"
 480     exe = self.bins("zzdir")
 481     run = shell("{exe} {getfile} ".format(**locals()))
 482     self.assertIn(' file.01\n', run.output)
 483     self.assertIn(' file.22\n', run.output)
 484     self.assertIn(' file.99\n', run.output)
 485     self.assertIn(' defl:N ', run.output)
 486     self.assertIn(' stored ', run.output)
 487   def test_20023_zzdir_test3_zip(self):
 488     """ run zzdir on test3.zip using just 'test3' """
 489     zipfile = "test3.zip"
 490     getfile = "test3"
 491     exe = self.bins("zzdir")
 492     run = shell("{exe} {getfile} ".format(**locals()))
 493     self.assertIn(' file.001\n', run.output)
 494     self.assertIn(' file.222\n', run.output)
 495     self.assertIn(' file.999\n', run.output)
 496     self.assertIn(' defl:N ', run.output)
 497     self.assertIn(' stored ', run.output)
 498   def test_20024_zzdir_test4_zip(self):
 499     """ run zzdir on test4.zip using just 'test4' """
 500     zipfile = "test4.zip"
 501     getfile = "test4"
 502     exe = self.bins("zzdir")
 503     run = shell("{exe} {getfile} ".format(**locals()))
 504     self.assertIn(' file0001.txt\n', run.output)
 505     self.assertIn(' file2222.txt\n', run.output)
 506     self.assertIn(' file9999.txt\n', run.output)
 507     self.assertNotIn(' defl:N ', run.output)
 508     self.assertIn(' stored ', run.output)
 509   def test_20320_zzxordir_test0_dat(self):
 510     """ run zzxordir on test0x.dat """
 511     zipfile = "test0x.dat"
 512     getfile = "test0x.dat"
 513     exe = self.bins("zzdir")
 514     run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1])
 515     self.assertEqual(run.returncode, 1)
 516     self.assertEqual("", run.output)
 517     self.assertIn("did not open test", run.errors)
 518     exe = self.bins("zzxordir")
 519     run = shell("{exe} {getfile} ".format(**locals()))
 520     self.assertIn(' README\n', run.output)
 521     self.assertIn(' defl:N ', run.output)
 522     self.assertLess(len(run.output), 30)
 523   def test_20321_zzxordir_test1_dat(self):
 524     """ run zzxordir on test1x.dat using just 'test1x' """
 525     zipfile = "test1x.dat"
 526     getfile = "test1x.dat"
 527     exe = self.bins("zzdir")
 528     run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1])
 529     self.assertEqual(run.returncode, 1)
 530     self.assertEqual("", run.output)
 531     self.assertIn("did not open test", run.errors)
 532     exe = self.bins("zzxordir")
 533     run = shell("{exe} {getfile} ".format(**locals()))
 534     self.assertIn(' file.1\n', run.output)
 535     self.assertIn(' file.2\n', run.output)
 536     self.assertIn(' file.9\n', run.output)
 537     self.assertIn(' README\n', run.output)
 538     self.assertIn(' defl:N ', run.output)
 539     self.assertIn(' stored ', run.output)
 540   def test_20322_zzxordir_test2_dat(self):
 541     """ run zzxordir on test2x.dat using just 'test2x' """
 542     zipfile = "test2x.dat"
 543     getfile = "test2x"
 544     exe = self.bins("zzdir")
 545     run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1])
 546     self.assertEqual(run.returncode, 1)
 547     self.assertEqual("", run.output)
 548     self.assertIn("did not open test", run.errors)
 549     exe = self.bins("zzxordir")
 550     run = shell("{exe} {getfile} ".format(**locals()))
 551     self.assertIn(' file.01\n', run.output)
 552     self.assertIn(' file.22\n', run.output)
 553     self.assertIn(' file.99\n', run.output)
 554     self.assertIn(' defl:N ', run.output)
 555     self.assertIn(' stored ', run.output)
 556   def test_20323_zzxordir_test3_dat(self):
 557     """ run zzxordir on test3x.dat using just 'test3x' """
 558     zipfile = "test3x.dat"
 559     getfile = "test3x"
 560     exe = self.bins("zzdir")
 561     run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1])
 562     self.assertEqual(run.returncode, 1)
 563     self.assertEqual("", run.output)
 564     self.assertIn("did not open test", run.errors)
 565     exe = self.bins("zzxordir")
 566     run = shell("{exe} {getfile} ".format(**locals()))
 567     self.assertIn(' file.001\n', run.output)
 568     self.assertIn(' file.222\n', run.output)
 569     self.assertIn(' file.999\n', run.output)
 570     self.assertIn(' defl:N ', run.output)
 571     self.assertIn(' stored ', run.output)
 572   def test_20324_zzxordir_test4_zip(self):
 573     """ run zzxordir on test4x.dat using just 'test4x' """
 574     zipfile = "test4x.dat"
 575     getfile = "test4x"
 576     exe = self.bins("zzdir")
 577     run = shell("{exe} {getfile} ".format(**locals()), returncodes = [0,1])
 578     self.assertEqual(run.returncode, 1)
 579     self.assertEqual("", run.output)
 580     self.assertIn("did not open test", run.errors)
 581     exe = self.bins("zzxordir")
 582     run = shell("{exe} {getfile} ".format(**locals()))
 583     self.assertIn(' file0001.txt\n', run.output)
 584     self.assertIn(' file2222.txt\n', run.output)
 585     self.assertIn(' file9999.txt\n', run.output)
 586     self.assertNotIn(' defl:N ', run.output)
 587     self.assertIn(' stored ', run.output)
 588   def test_20340_zzxorcat_test0_zip(self):
 589     """ run zzxorcat on testx.zip using just testx/README """
 590     getfile = "test0x/README"
 591     logfile = "test0x.readme.txt"
 592     exe = self.bins("zzcat")
 593     run = shell("{exe} {getfile} ".format(**locals()), lang="C")
 594     self.assertEqual("", run.output)
 595     self.assertIn("No such file or directory", run.errors)
 596     exe = self.bins("zzxorcat")
 597     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 598     self.assertGreater(os.path.getsize(logfile), 10)
 599     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 600   def test_20341_zzxorcat_test1_zip(self):
 601     """ run zzxorcat on testx.zip using just testx/README """
 602     getfile = "test1x/README"
 603     logfile = "test1x.readme.txt"
 604     exe = self.bins("zzcat")
 605     run = shell("{exe} {getfile} ".format(**locals()), lang="C")
 606     self.assertEqual("", run.output)
 607     self.assertIn("No such file or directory", run.errors)
 608     exe = self.bins("zzxorcat")
 609     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 610     self.assertGreater(os.path.getsize(logfile), 10)
 611     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 612     getfile = "test1x/file.1"
 613     run = shell("{exe} {getfile}".format(**locals()))
 614     self.assertEqual("file-1\n", run.output)
 615   def test_20342_zzxorcat_test2_zip(self):
 616     """ run zzxorcat on testx.zip using just testx/README """
 617     getfile = "test2x/README"
 618     logfile = "test2x.readme.txt"
 619     exe = self.bins("zzcat")
 620     run = shell("{exe} {getfile} ".format(**locals()), lang="C")
 621     self.assertEqual("", run.output)
 622     self.assertIn("No such file or directory", run.errors)
 623     exe = self.bins("zzxorcat")
 624     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 625     self.assertGreater(os.path.getsize(logfile), 10)
 626     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 627     getfile = "test2x/file.22"
 628     run = shell("{exe} {getfile}".format(**locals()))
 629     self.assertEqual("file-22\n", run.output)
 630   def test_20343_zzxorcat_test3_zip(self):
 631     """ run zzxorcat on testx.zip using just testx/README """
 632     getfile = "test3x/README"
 633     logfile = "test3x.readme.txt"
 634     exe = self.bins("zzcat")
 635     run = shell("{exe} {getfile} ".format(**locals()), lang="C")
 636     self.assertEqual("", run.output)
 637     self.assertIn("No such file or directory", run.errors)
 638     exe = self.bins("zzxorcat")
 639     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 640     self.assertGreater(os.path.getsize(logfile), 10)
 641     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 642     getfile = "test3x/file.999"
 643     run = shell("{exe} {getfile}".format(**locals()))
 644     self.assertEqual("file-999\n", run.output)
 645   def test_20344_zzxorcat_test4_zip(self):
 646     """ run zzxorcat on testx.zip using just testx/README """
 647     getfile = "test4x/README"
 648     logfile = "test4x.readme.txt"
 649     exe = self.bins("zzxorcat")
 650     run = shell("{exe} {getfile} | tee {logfile}".format(**locals()))
 651     self.assertGreater(os.path.getsize(logfile), 10)
 652     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 653     getfile = "test4x/file9999.txt"
 654     run = shell("{exe} {getfile}".format(**locals()))
 655     self.assertEqual("file-9999\n", run.output)
 656   #####################################################################
 657   # check unzzip
 658   #####################################################################
 659   def test_20400_infozip_cat_test0_zip(self):
 660     """ run inzo-zip cat test.zip using just archive README """
 661     zipfile = "test0.zip"
 662     getfile = "README"
 663     logfile = "test0.readme.pk.txt"
 664     exe = self.bins("unzip")
 665     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 666     self.assertGreater(os.path.getsize(logfile), 10)
 667     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 668   def test_20401_infozip_cat_test1_zip(self):
 669     """ run info-zip cat test.zip using just archive README """
 670     zipfile = "test1.zip"
 671     getfile = "README"
 672     logfile = "test1.readme.pk.txt"
 673     exe = self.bins("unzip")
 674     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 675     self.assertGreater(os.path.getsize(logfile), 10)
 676     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 677     getfile = "file.1"
 678     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 679     self.assertEqual("file-1\n", run.output)
 680   def test_20402_infozip_cat_test2_zip(self):
 681     """ run info-zip cat test.zip using just archive README """
 682     zipfile = "test2.zip"
 683     getfile = "README"
 684     logfile = "test2.readme.pk.txt"
 685     exe = self.bins("unzip")
 686     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 687     self.assertGreater(os.path.getsize(logfile), 10)
 688     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 689     getfile = "file.22"
 690     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 691     self.assertEqual("file-22\n", run.output)
 692   def test_20405_zzcat_big_test5_zip(self):
 693     """ run info-zip cat test.zip using archive README """
 694     zipfile = "test5.zip"
 695     getfile = "README"
 696     logfile = "test5.readme.pk.txt"
 697     exe = self.bins("unzip")
 698     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 699     self.assertGreater(os.path.getsize(logfile), 10)
 700     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 701     getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt"
 702     compare = self.gentext(1024)
 703     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 704     self.assertEqual(compare, run.output)
 705   def test_20410_zzcat_big_test0_zip(self):
 706     """ run zzcat-big on test.zip using just archive README """
 707     zipfile = "test0.zip"
 708     getfile = "README"
 709     logfile = "test0.readme.big.txt"
 710     exe = self.bins("unzzip-big")
 711     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 712     self.assertGreater(os.path.getsize(logfile), 10)
 713     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 714   def test_20411_zzcat_big_test1_zip(self):
 715     """ run zzcat-big on test.zip using just archive README """
 716     zipfile = "test1.zip"
 717     getfile = "README"
 718     logfile = "test1.readme.big.txt"
 719     exe = self.bins("unzzip-big")
 720     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 721     self.assertGreater(os.path.getsize(logfile), 10)
 722     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 723     getfile = "file.1"
 724     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 725     self.assertEqual("file-1\n", run.output)
 726   def test_20412_zzcat_big_test2_zip(self):
 727     """ run zzcat-seeke on test.zip using just archive README """
 728     zipfile = "test2.zip"
 729     getfile = "README"
 730     logfile = "test2.readme.big.txt"
 731     exe = self.bins("unzzip-big")
 732     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 733     self.assertGreater(os.path.getsize(logfile), 10)
 734     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 735     getfile = "file.22"
 736     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 737     self.assertEqual("file-22\n", run.output)
 738   def test_20415_zzcat_big_test5_zip(self):
 739     """ run zzcat-big on test.zip using archive README """
 740     zipfile = "test5.zip"
 741     getfile = "README"
 742     logfile = "test5.readme.zap.txt"
 743     exe = self.bins("unzzip-big")
 744     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 745     self.assertGreater(os.path.getsize(logfile), 10)
 746     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 747     getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt"
 748     compare = self.gentext(1024)
 749     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 750     self.assertEqual(compare, run.output)
 751   def test_20420_zzcat_mem_test0_zip(self):
 752     """ run zzcat-mem on test.zip using just archive README """
 753     zipfile = "test0.zip"
 754     getfile = "README"
 755     logfile = "test0.readme.mem.txt"
 756     exe = self.bins("unzzip-mem")
 757     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 758     self.assertGreater(os.path.getsize(logfile), 10)
 759     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 760   def test_20421_zzcat_mem_test1_zip(self):
 761     """ run zzcat-mem on test.zip using archive README """
 762     zipfile = "test1.zip"
 763     getfile = "README"
 764     logfile = "test1.readme.mem.txt"
 765     exe = self.bins("unzzip-mem")
 766     run = shell("{exe} -p {zipfile}  {getfile} | tee {logfile}".format(**locals()))
 767     self.assertGreater(os.path.getsize(logfile), 10)
 768     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 769     getfile = "file.1"
 770     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 771     self.assertEqual("file-1\n", run.output)
 772   def test_20422_zzcat_mem_test2_zip(self):
 773     """ run zzcat-mem on test.zip using archive README """
 774     zipfile = "test2.zip"
 775     getfile = "README"
 776     logfile = "test2.readme.mem.txt"
 777     exe = self.bins("unzzip-mem")
 778     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 779     self.assertGreater(os.path.getsize(logfile), 10)
 780     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 781     getfile = "file.22"
 782     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 783     self.assertEqual("file-22\n", run.output)
 784   def test_20423_zzcat_mem_test3_zip(self):
 785     """ run zzcat-mem on test.zip using archive README """
 786     zipfile = "test3.zip"
 787     getfile = "README"
 788     logfile = "test3.readme.mem.txt"
 789     exe = self.bins("unzzip-mem")
 790     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 791     self.assertGreater(os.path.getsize(logfile), 10)
 792     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 793     getfile = "file.999"
 794     run = shell("{exe} -p {zipfile}  {getfile}".format(**locals()))
 795     self.assertEqual("file-999\n", run.output)
 796   def test_20424_zzcat_mem_test4_zip(self):
 797     """ run zzcat-mem on test.zip using archive README """
 798     zipfile = "test4.zip"
 799     getfile = "README"
 800     logfile = "test4.readme.mem.txt"
 801     exe = self.bins("unzzip-mem")
 802     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 803     self.assertGreater(os.path.getsize(logfile), 10)
 804     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 805     getfile = "file9999.txt"
 806     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 807     self.assertEqual("file-9999\n", run.output)
 808   def test_20425_zzcat_mem_test5_zip(self):
 809     """ run zzcat-mem on test.zip using archive README """
 810     zipfile = "test5.zip"
 811     getfile = "README"
 812     logfile = "test5.readme.zap.txt"
 813     exe = self.bins("unzzip-mem")
 814     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 815     self.assertGreater(os.path.getsize(logfile), 10)
 816     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 817     getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt"
 818     compare = self.gentext(1024)
 819     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 820     self.assertEqual(compare, run.output)
 821   def test_20430_zzcat_mix_test0_zip(self):
 822     """ run zzcat-mix on test.zip using just archive README """
 823     zipfile = "test0.zip"
 824     getfile = "README"
 825     logfile = "test0.readme.mix.txt"
 826     exe = self.bins("unzzip-mix")
 827     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 828     self.assertGreater(os.path.getsize(logfile), 10)
 829     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 830   def test_20431_zzcat_mix_test1_zip(self):
 831     """ run zzcat-mix on test.zip using archive README """
 832     zipfile = "test1.zip"
 833     getfile = "README"
 834     logfile = "test1.readme.mix.txt"
 835     exe = self.bins("unzzip-mix")
 836     run = shell("{exe} -p {zipfile}  {getfile} | tee {logfile}".format(**locals()))
 837     self.assertGreater(os.path.getsize(logfile), 10)
 838     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 839     getfile = "file.1"
 840     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 841     self.assertEqual("file-1\n", run.output)
 842   def test_20432_zzcat_mix_test2_zip(self):
 843     """ run zzcat-mix on test.zip using archive README """
 844     zipfile = "test2.zip"
 845     getfile = "README"
 846     logfile = "test2.readme.mix.txt"
 847     exe = self.bins("unzzip-mix")
 848     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 849     self.assertGreater(os.path.getsize(logfile), 10)
 850     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 851     getfile = "file.22"
 852     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 853     self.assertEqual("file-22\n", run.output)
 854   def test_20433_zzcat_mix_test3_zip(self):
 855     """ run zzcat-mix on test.zip using archive README """
 856     zipfile = "test3.zip"
 857     getfile = "README"
 858     logfile = "test3.readme.mix.txt"
 859     exe = self.bins("unzzip-mix")
 860     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 861     self.assertGreater(os.path.getsize(logfile), 10)
 862     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 863     getfile = "file.999"
 864     run = shell("{exe} -p {zipfile}  {getfile}".format(**locals()))
 865     self.assertEqual("file-999\n", run.output)
 866   def test_20434_zzcat_mix_test4_zip(self):
 867     """ run zzcat-mix on test.zip using archive README """
 868     zipfile = "test4.zip"
 869     getfile = "README"
 870     logfile = "test4.readme.mix.txt"
 871     exe = self.bins("unzzip-mix")
 872     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 873     self.assertGreater(os.path.getsize(logfile), 10)
 874     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 875     getfile = "file9999.txt"
 876     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 877     self.assertEqual("file-9999\n", run.output)
 878   def test_20435_zzcat_mix_test5_zip(self):
 879     """ run zzcat-mix on test.zip using archive README """
 880     zipfile = "test5.zip"
 881     getfile = "README"
 882     logfile = "test5.readme.zap.txt"
 883     exe = self.bins("unzzip-mix")
 884     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 885     self.assertGreater(os.path.getsize(logfile), 10)
 886     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 887     getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt"
 888     compare = self.gentext(1024)
 889     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 890     self.assertEqual(compare, run.output)
 891   def test_20440_zzcat_zap_test0_zip(self):
 892     """ run zzcat-zap on test.zip using just archive README """
 893     zipfile = "test0.zip"
 894     getfile = "README"
 895     logfile = "test0.readme.txt"
 896     exe = self.bins("unzzip")
 897     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 898     self.assertGreater(os.path.getsize(logfile), 10)
 899     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 900   def test_20441_zzcat_zap_test1_zip(self):
 901     """ run zzcat-zap on test.zip using archive README """
 902     zipfile = "test1.zip"
 903     getfile = "README"
 904     logfile = "test1.readme.zap.txt"
 905     exe = self.bins("unzzip")
 906     run = shell("{exe} -p {zipfile}  {getfile} | tee {logfile}".format(**locals()))
 907     self.assertGreater(os.path.getsize(logfile), 10)
 908     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 909     getfile = "file.1"
 910     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 911     self.assertEqual("file-1\n", run.output)
 912   def test_20442_zzcat_zap_test2_zip(self):
 913     """ run zzcat-zap on test.zip using archive README """
 914     zipfile = "test2.zip"
 915     getfile = "README"
 916     logfile = "test2.readme.zap.txt"
 917     exe = self.bins("unzzip")
 918     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 919     self.assertGreater(os.path.getsize(logfile), 10)
 920     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 921     getfile = "file.22"
 922     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 923     self.assertEqual("file-22\n", run.output)
 924   def test_20443_zzcat_zap_test3_zip(self):
 925     """ run zzcat-zap on test.zip using archive README """
 926     zipfile = "test3.zip"
 927     getfile = "README"
 928     logfile = "test3.readme.zap.txt"
 929     exe = self.bins("unzzip")
 930     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 931     self.assertGreater(os.path.getsize(logfile), 10)
 932     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 933     getfile = "file.999"
 934     run = shell("{exe} -p {zipfile}  {getfile}".format(**locals()))
 935     self.assertEqual("file-999\n", run.output)
 936   def test_20444_zzcat_zap_test4_zip(self):
 937     """ run zzcat-zap on test.zip using archive README """
 938     zipfile = "test4.zip"
 939     getfile = "README"
 940     logfile = "test4.readme.zap.txt"
 941     exe = self.bins("unzzip")
 942     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 943     self.assertGreater(os.path.getsize(logfile), 10)
 944     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 945     getfile = "file9999.txt"
 946     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 947     self.assertEqual("file-9999\n", run.output)
 948   def test_20445_zzcat_zap_test5_zip(self):
 949     """ run zzcat-zap on test.zip using archive README """
 950     zipfile = "test5.zip"
 951     getfile = "README"
 952     logfile = "test5.readme.zap.txt"
 953     exe = self.bins("unzzip")
 954     run = shell("{exe} -p {zipfile} {getfile} | tee {logfile}".format(**locals()))
 955     self.assertGreater(os.path.getsize(logfile), 10)
 956     self.assertEqual(run.output.split("\n"), self.readme().split("\n"))
 957     getfile = "subdir1/subdir2/subdir3/subdir4/subdir5/subdir6/file7-1024.txt"
 958     compare = self.gentext(1024)
 959     run = shell("{exe} -p {zipfile} {getfile}".format(**locals()))
 960     self.assertEqual(compare, run.output)
 961
 962   def test_20500_infozipdir_test0_zip(self):
 963     """ run info-zip dir test0.zip  """
 964     zipfile = "test0.zip"
 965     getfile = "test0.zip"
 966     exe = self.bins("unzip")
 967     run = shell("{exe} -l {getfile} ".format(**locals()))
 968     self.assertIn(' README\n', run.output)
 969     self.assertLess(len(run.output), 230)
 970   def test_20501_infozipdir_test1_zip(self):
 971     """ run info-zip dir test1.zip  """
 972     zipfile = "test1.zip"
 973     getfile = "test1.zip"
 974     exe = self.bins("unzip")
 975     run = shell("{exe} -l {getfile} ".format(**locals()))
 976     self.assertIn(' file.1\n', run.output)
 977     self.assertIn(' file.2\n', run.output)
 978     self.assertIn(' file.9\n', run.output)
 979     self.assertIn(' README\n', run.output)
 980   def test_20502_infozipdir_big_test2_zip(self):
 981     """ run info-zip dir test2.zip """
 982     zipfile = "test2.zip"
 983     getfile = "test2.zip"
 984     exe = self.bins("unzip")
 985     run = shell("{exe} -l {getfile} ".format(**locals()))
 986     self.assertIn(' file.01\n', run.output)
 987     self.assertIn(' file.22\n', run.output)
 988     self.assertIn(' file.99\n', run.output)
 989   def test_20503_infozipdir_big_test3_zip(self):
 990     """ run info-zip dir test3.zip  """
 991     zipfile = "test3.zip"
 992     getfile = "test3.zip"
 993     exe = self.bins("unzip")
 994     run = shell("{exe} -l {getfile} ".format(**locals()))
 995     self.assertIn(' file.001\n', run.output)
 996     self.assertIn(' file.222\n', run.output)
 997     self.assertIn(' file.999\n', run.output)
 998   def test_20504_infozipdir_big_test4_zip(self):
 999     """ run info-zip dir test4.zip """
1000     zipfile = "test4.zip"
1001     getfile = "test4.zip"
1002     exe = self.bins("unzip")
1003     run = shell("{exe} -l {getfile} ".format(**locals()))
1004     self.assertIn(' file0001.txt\n', run.output)
1005     self.assertIn(' file2222.txt\n', run.output)
1006     self.assertIn(' file9999.txt\n', run.output)
1007   def test_20505_infozipdir_big_test5_zip(self):
1008     """ run info-zip dir on test5.zip """
1009     zipfile = "test5.zip"
1010     getfile = "test5.zip"
1011     exe = self.bins("unzzip-mix")
1012     run = shell("{exe} -v {getfile} ".format(**locals()))
1013     self.assertIn('/subdir14/file15-128.txt\n', run.output)
1014     self.assertIn('/subdir5/subdir6/', run.output)
1015     self.assertIn(' defl:N ', run.output)
1016     self.assertIn(' stored ', run.output)
1017   def test_20510_zzdir_big_test0_zip(self):
1018     """ run zzdir-big on test0.zip  """
1019     zipfile = "test0.zip"
1020     getfile = "test0.zip"
1021     exe = self.bins("unzzip-big")
1022     run = shell("{exe} -l {getfile} ".format(**locals()))
1023     self.assertIn(' README\n', run.output)
1024     self.assertLess(len(run.output), 30)
1025   def test_20511_zzdir_big_test1_zip(self):
1026     """ run zzdir-big on test1.zip  """
1027     zipfile = "test1.zip"
1028     getfile = "test1.zip"
1029     exe = self.bins("unzzip-big")
1030     run = shell("{exe} -l {getfile} ".format(**locals()))
1031     self.assertIn(' file.1\n', run.output)
1032     self.assertIn(' file.2\n', run.output)
1033     self.assertIn(' file.9\n', run.output)
1034     self.assertIn(' README\n', run.output)
1035   def test_20512_zzdir_big_test2_zip(self):
1036     """ run zzdir-big on test2.zip """
1037     zipfile = "test2.zip"
1038     getfile = "test2.zip"
1039     exe = self.bins("unzzip-big")
1040     run = shell("{exe} -l {getfile} ".format(**locals()))
1041     self.assertIn(' file.01\n', run.output)
1042     self.assertIn(' file.22\n', run.output)
1043     self.assertIn(' file.99\n', run.output)
1044   def test_20513_zzdir_big_test3_zip(self):
1045     """ run zzdir-big on test3.zip  """
1046     zipfile = "test3.zip"
1047     getfile = "test3.zip"
1048     exe = self.bins("unzzip-big")
1049     run = shell("{exe} -l {getfile} ".format(**locals()))
1050     self.assertIn(' file.001\n', run.output)
1051     self.assertIn(' file.222\n', run.output)
1052     self.assertIn(' file.999\n', run.output)
1053   def test_20514_zzdir_big_test4_zip(self):
1054     """ run zzdir-big on test4.zip """
1055     zipfile = "test4.zip"
1056     getfile = "test4.zip"
1057     exe = self.bins("unzzip-big")
1058     run = shell("{exe} -l {getfile} ".format(**locals()))
1059     self.assertIn(' file0001.txt\n', run.output)
1060     self.assertIn(' file2222.txt\n', run.output)
1061     self.assertIn(' file9999.txt\n', run.output)
1062   def test_20515_zzdir_big_test5_zip(self):
1063     """ run zzdir-big on test5.zip """
1064     zipfile = "test5.zip"
1065     getfile = "test5.zip"
1066     exe = self.bins("unzzip-mix")
1067     run = shell("{exe} -v {getfile} ".format(**locals()))
1068     self.assertIn('/subdir14/file15-128.txt\n', run.output)
1069     self.assertIn('/subdir5/subdir6/', run.output)
1070     self.assertIn(' defl:N ', run.output)
1071     self.assertIn(' stored ', run.output)
1072   def test_20520_zzdir_mem_test0_zip(self):
1073     """ run zzdir-mem on test0.zip  """
1074     zipfile = "test0.zip"
1075     getfile = "test0.zip"
1076     exe = self.bins("unzzip-mem")
1077     run = shell("{exe} -v {getfile} ".format(**locals()))
1078     self.assertIn(' README\n', run.output)
1079     self.assertIn(' defl:N ', run.output)
1080     self.assertLess(len(run.output), 30)
1081   def test_20521_zzdir_mem_test1_zip(self):
1082     """ run zzdir-mem on test1.zip  """
1083     zipfile = "test1.zip"
1084     getfile = "test1.zip"
1085     exe = self.bins("unzzip-mem")
1086     run = shell("{exe} -v {getfile} ".format(**locals()))
1087     self.assertIn(' file.1\n', run.output)
1088     self.assertIn(' file.2\n', run.output)
1089     self.assertIn(' file.9\n', run.output)
1090     self.assertIn(' README\n', run.output)
1091     self.assertIn(' defl:N ', run.output)
1092     self.assertIn(' stored ', run.output)
1093   def test_20522_zzdir_mem_test2_zip(self):
1094     """ run zzdir-mem on test2.zip """
1095     zipfile = "test2.zip"
1096     getfile = "test2.zip"
1097     exe = self.bins("unzzip-mem")
1098     run = shell("{exe} -v {getfile} ".format(**locals()))
1099     self.assertIn(' file.01\n', run.output)
1100     self.assertIn(' file.22\n', run.output)
1101     self.assertIn(' file.99\n', run.output)
1102     self.assertIn(' defl:N ', run.output)
1103     self.assertIn(' stored ', run.output)
1104   def test_20523_zzdir_mem_test3_zip(self):
1105     """ run zzdir-mem on test3.zip  """
1106     zipfile = "test3.zip"
1107     getfile = "test3.zip"
1108     exe = self.bins("unzzip-mem")
1109     run = shell("{exe} -v {getfile} ".format(**locals()))
1110     self.assertIn(' file.001\n', run.output)
1111     self.assertIn(' file.222\n', run.output)
1112     self.assertIn(' file.999\n', run.output)
1113     self.assertIn(' defl:N ', run.output)
1114     self.assertIn(' stored ', run.output)
1115   def test_20524_zzdir_mem_test4_zip(self):
1116     """ run zzdir-mem on test4.zip """
1117     zipfile = "test4.zip"
1118     getfile = "test4.zip"
1119     exe = self.bins("unzzip-mem")
1120     run = shell("{exe} -v {getfile} ".format(**locals()))
1121     self.assertIn(' file0001.txt\n', run.output)
1122     self.assertIn(' file2222.txt\n', run.output)
1123     self.assertIn(' file9999.txt\n', run.output)
1124     self.assertNotIn(' defl:N ', run.output)
1125     self.assertIn(' stored ', run.output)
1126   def test_20525_zzdir_mem_test5_zip(self):
1127     """ run zzdir-mem on test5.zip """
1128     zipfile = "test5.zip"
1129     getfile = "test5.zip"
1130     exe = self.bins("unzzip-mix")
1131     run = shell("{exe} -v {getfile} ".format(**locals()))
1132     self.assertIn('/subdir14/file15-128.txt\n', run.output)
1133     self.assertIn('/subdir5/subdir6/', run.output)
1134     self.assertIn(' defl:N ', run.output)
1135     self.assertIn(' stored ', run.output)
1136   def test_20530_zzdir_mix_test0_zip(self):
1137     """ run zzdir-mix on test0.zip  """
1138     # self.skipTest("todo")
1139     zipfile = "test0.zip"
1140     getfile = "test0.zip"
1141     exe = self.bins("unzzip-mix")
1142     run = shell("{exe} -v {getfile} ".format(**locals()))
1143     self.assertIn(' README\n', run.output)
1144     self.assertIn(' defl:N ', run.output)
1145     self.assertLess(len(run.output), 30)
1146   def test_20531_zzdir_mix_test1_zip(self):
1147     """ run zzdir-mix on test1.zip  """
1148     zipfile = "test1.zip"
1149     getfile = "test1.zip"
1150     exe = self.bins("unzzip-mix")
1151     run = shell("{exe} -v {getfile} ".format(**locals()))
1152     self.assertIn(' file.1\n', run.output)
1153     self.assertIn(' file.2\n', run.output)
1154     self.assertIn(' file.9\n', run.output)
1155     self.assertIn(' README\n', run.output)
1156     self.assertIn(' defl:N ', run.output)
1157     self.assertIn(' stored ', run.output)
1158   def test_20532_zzdir_mix_test2_zip(self):
1159     """ run zzdir-mix on test2.zip """
1160     zipfile = "test2.zip"
1161     getfile = "test2.zip"
1162     exe = self.bins("unzzip-mix")
1163     run = shell("{exe} -v {getfile} ".format(**locals()))
1164     self.assertIn(' file.01\n', run.output)
1165     self.assertIn(' file.22\n', run.output)
1166     self.assertIn(' file.99\n', run.output)
1167     self.assertIn(' defl:N ', run.output)
1168     self.assertIn(' stored ', run.output)
1169   def test_20533_zzdir_mix_test3_zip(self):
1170     """ run zzdir-mix on test3.zip  """
1171     zipfile = "test3.zip"
1172     getfile = "test3.zip"
1173     exe = self.bins("unzzip-mix")
1174     run = shell("{exe} -v {getfile} ".format(**locals()))
1175     self.assertIn(' file.001\n', run.output)
1176     self.assertIn(' file.222\n', run.output)
1177     self.assertIn(' file.999\n', run.output)
1178     self.assertIn(' defl:N ', run.output)
1179     self.assertIn(' stored ', run.output)
1180   def test_20534_zzdir_mix_test4_zip(self):
1181     """ run zzdir-mix on test4.zip """
1182     zipfile = "test4.zip"
1183     getfile = "test4.zip"
1184     exe = self.bins("unzzip-mix")
1185     run = shell("{exe} -v {getfile} ".format(**locals()))
1186     self.assertIn(' file0001.txt\n', run.output)
1187     self.assertIn(' file2222.txt\n', run.output)
1188     self.assertIn(' file9999.txt\n', run.output)
1189     self.assertNotIn(' defl:N ', run.output)
1190     self.assertIn(' stored ', run.output)
1191   def test_20535_zzdir_mix_test5_zip(self):
1192     """ run zzdir-mix on test5.zip """
1193     zipfile = "test5.zip"
1194     getfile = "test5.zip"
1195     exe = self.bins("unzzip-mix")
1196     run = shell("{exe} -v {getfile} ".format(**locals()))
1197     self.assertIn('/subdir14/file15-128.txt\n', run.output)
1198     self.assertIn('/subdir5/subdir6/', run.output)
1199     self.assertIn(' defl:N ', run.output)
1200     self.assertIn(' stored ', run.output)
1201   def test_20540_zzdir_zap_test0_zip(self):
1202     """ run zzdir-zap on test0.zip  """
1203     zipfile = "test0.zip"
1204     getfile = "test0.zip"
1205     exe = self.bins("unzzip")
1206     run = shell("{exe} -v {getfile} ".format(**locals()))
1207     self.assertIn(' README\n', run.output)
1208     self.assertIn(' defl:N ', run.output)
1209     self.assertLess(len(run.output), 30)
1210   def test_20541_zzdir_zap_test1_zip(self):
1211     """ run zzdir-zap on test1.zip  """
1212     zipfile = "test1.zip"
1213     getfile = "test1.zip"
1214     exe = self.bins("unzzip")
1215     run = shell("{exe} -v {getfile} ".format(**locals()))
1216     self.assertIn(' file.1\n', run.output)
1217     self.assertIn(' file.2\n', run.output)
1218     self.assertIn(' file.9\n', run.output)
1219     self.assertIn(' README\n', run.output)
1220     self.assertIn(' defl:N ', run.output)
1221     self.assertIn(' stored ', run.output)
1222   def test_20542_zzdir_zap_test2_zip(self):
1223     """ run zzdir-zap on test2.zip """
1224     zipfile = "test2.zip"
1225     getfile = "test2.zip"
1226     exe = self.bins("unzzip")
1227     run = shell("{exe} -v {getfile} ".format(**locals()))
1228     self.assertIn(' file.01\n', run.output)
1229     self.assertIn(' file.22\n', run.output)
1230     self.assertIn(' file.99\n', run.output)
1231     self.assertIn(' defl:N ', run.output)
1232     self.assertIn(' stored ', run.output)
1233   def test_20543_zzdir_zap_test3_zip(self):
1234     """ run zzdir-zap on test3.zip  """
1235     zipfile = "test3.zip"
1236     getfile = "test3.zip"
1237     exe = self.bins("unzzip")
1238     run = shell("{exe} -v {getfile} ".format(**locals()))
1239     self.assertIn(' file.001\n', run.output)
1240     self.assertIn(' file.222\n', run.output)
1241     self.assertIn(' file.999\n', run.output)
1242     self.assertIn(' defl:N ', run.output)
1243     self.assertIn(' stored ', run.output)
1244   def test_20544_zzdir_zap_test4_zip(self):
1245     """ run zzdir-zap on test4.zip """
1246     zipfile = "test4.zip"
1247     getfile = "test4.zip"
1248     exe = self.bins("unzzip")
1249     run = shell("{exe} -v {getfile} ".format(**locals()))
1250     self.assertIn(' file0001.txt\n', run.output)
1251     self.assertIn(' file2222.txt\n', run.output)
1252     self.assertIn(' file9999.txt\n', run.output)
1253     self.assertNotIn(' defl:N ', run.output)
1254     self.assertIn(' stored ', run.output)
1255   def test_20545_zzdir_zap_test5_zip(self):
1256     """ run zzdir-zap on test5.zip """
1257     zipfile = "test5.zip"
1258     getfile = "test5.zip"
1259     exe = self.bins("unzzip")
1260     run = shell("{exe} -v {getfile} ".format(**locals()))
1261     self.assertIn('/subdir14/file15-128.txt\n', run.output)
1262     self.assertIn('/subdir5/subdir6/', run.output)
1263     self.assertIn(' defl:N ', run.output)
1264     self.assertIn(' stored ', run.output)
1265   def test_20595_zzextract_zap_test5_zip(self):
1266     """ run zzextract-zap on test5.zip
1267         => coughs up a SEGFAULT in zzip_dir_close() ?!?"""
1268     zipfile = "test5.zip"
1269     getfile = "test5.zip"
1270     tmpdir = self.testdir()
1271     exe = self.bins("unzzip")
1272     run = shell("cd {tmpdir} && ../{exe} ../{getfile} ".format(**locals()))
1273     self.assertTrue(tmpdir+'/subdir1/subdir2/file3-1024.txt')
1274     self.rm_testdir()
1275
1276   url_CVE_2017_5977 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1277   zip_CVE_2017_5977 = "00153-zziplib-invalidread-zzip_mem_entry_extra_block"
1278   def test_59770_infozipdir_CVE_2017_5977(self):
1279     """ run info-zip dir test0.zip  """
1280     tmpdir = self.testdir()
1281     filename = self.zip_CVE_2017_5977
1282     file_url = self.url_CVE_2017_5977
1283     download(file_url, filename, tmpdir)
1284     exe = self.bins("unzip")
1285     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1286         returncodes = [0, 2])
1287     self.assertIn(" didn't find end-of-central-dir signature at end of central dir", run.errors)
1288     self.assertIn(" 2 extra bytes at beginning or within zipfile", run.errors)
1289     self.assertLess(len(run.output), 280)
1290     self.rm_testdir()
1291   def test_59771_zzipdir_big_CVE_2017_5977(self):
1292     """ run info-zip -l $(CVE_2017_5977).zip  """
1293     tmpdir = self.testdir()
1294     filename = self.zip_CVE_2017_5977
1295     file_url = self.url_CVE_2017_5977
1296     download(file_url, filename, tmpdir)
1297     exe = self.bins("unzzip-big")
1298     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1299         returncodes = [0])
1300     self.assertLess(len(run.output), 30)
1301     self.assertLess(len(errors(run.errors)), 1)
1302     self.assertIn(" stored test", run.output)
1303     self.rm_testdir()
1304   def test_59772_zzipdir_mem_CVE_2017_5977(self):
1305     """ run unzzip-mem -l $(CVE_2017_5977).zip  """
1306     tmpdir = self.testdir()
1307     filename = self.zip_CVE_2017_5977
1308     file_url = self.url_CVE_2017_5977
1309     download(file_url, filename, tmpdir)
1310     exe = self.bins("unzzip-mem")
1311     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1312         returncodes = [0])
1313     self.assertLess(len(run.output), 30)
1314     self.assertLess(len(errors(run.errors)), 1)
1315     self.assertIn(" 3 test", run.output)
1316     self.rm_testdir()
1317   def test_59773_zzipdir_mix_CVE_2017_5977(self):
1318     """ run unzzip-mix -l $(CVE_2017_5977).zip  """
1319     tmpdir = self.testdir()
1320     filename = self.zip_CVE_2017_5977
1321     file_url = self.url_CVE_2017_5977
1322     download(file_url, filename, tmpdir)
1323     exe = self.bins("unzzip-mix")
1324     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1325         returncodes = [0])
1326     self.assertLess(len(run.output), 30)
1327     self.assertLess(len(errors(run.errors)), 1)
1328     self.assertIn(" 3 test", run.output)
1329     self.rm_testdir()
1330   def test_59774_zzipdir_zap_CVE_2017_5977(self):
1331     """ run unzzip -l $(CVE_2017_5977).zip  """
1332     tmpdir = self.testdir()
1333     filename = self.zip_CVE_2017_5977
1334     file_url = self.url_CVE_2017_5977
1335     download(file_url, filename, tmpdir)
1336     exe = self.bins("unzzip")
1337     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1338         returncodes = [0, 255])
1339     self.assertLess(len(run.output), 30)
1340     self.assertLess(len(errors(run.errors)), 1)
1341     self.assertIn(" 3 test", run.output)
1342     self.rm_testdir()
1343   def test_59775_zipext_info_CVE_2017_5977(self):
1344     """ run info' unzip $(CVE_2017_5977).zip  """
1345     tmpdir = self.testdir()
1346     filename = self.zip_CVE_2017_5977
1347     file_url = self.url_CVE_2017_5977
1348     download(file_url, filename, tmpdir)
1349     exe = self.bins("unzip")
1350     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
1351         returncodes = [2])
1352     self.assertLess(len(run.output), 90)
1353     self.assertLess(len(errors(run.errors)), 900)
1354     self.assertIn('test:  mismatching "local" filename', run.errors)
1355     self.assertIn('test:  unknown compression method', run.errors)
1356     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1357     self.rm_testdir()
1358   def test_59776_zzipext_big_CVE_2017_5977(self):
1359     """ run unzzip-big $(CVE_2017_5977).zip  """
1360     tmpdir = self.testdir()
1361     filename = self.zip_CVE_2017_5977
1362     file_url = self.url_CVE_2017_5977
1363     download(file_url, filename, tmpdir)
1364     exe = self.bins("unzzip-big")
1365     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1366         returncodes = [0])
1367     self.assertLess(len(run.output), 30)
1368     self.assertLess(len(errors(run.errors)), 1)
1369     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1370     self.rm_testdir()
1371   @unittest.expectedFailure
1372   def test_59777_zzipext_mem_CVE_2017_5977(self):
1373     """ run unzzip-mem $(CVE_2017_5977).zip  """
1374     tmpdir = self.testdir()
1375     filename = self.zip_CVE_2017_5977
1376     file_url = self.url_CVE_2017_5977
1377     download(file_url, filename, tmpdir)
1378     exe = self.bins("unzzip-mem")
1379     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1380         returncodes = [0])
1381     self.assertLess(len(run.output), 30)
1382     self.assertLess(len(errors(run.errors)), 1)
1383     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1384     self.rm_testdir()
1385   def test_59778_zzipext_mix_CVE_2017_5977(self):
1386     """ run unzzip-mix $(CVE_2017_5977).zip  """
1387     tmpdir = self.testdir()
1388     filename = self.zip_CVE_2017_5977
1389     file_url = self.url_CVE_2017_5977
1390     download(file_url, filename, tmpdir)
1391     exe = self.bins("unzzip-mix")
1392     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1393         returncodes = [0])
1394     self.assertLess(len(run.output), 30)
1395     self.assertLess(len(errors(run.errors)), 1)
1396     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1397     self.rm_testdir()
1398   def test_59779_zzipext_zap_CVE_2017_5977(self):
1399     """ run unzzip $(CVE_2017_5977).zip  """
1400     tmpdir = self.testdir()
1401     filename = self.zip_CVE_2017_5977
1402     file_url = self.url_CVE_2017_5977
1403     download(file_url, filename, tmpdir)
1404     exe = self.bins("unzzip")
1405     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1406         returncodes = [0])
1407     self.assertLess(len(run.output), 30)
1408     self.assertLess(len(errors(run.errors)), 1)
1409     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3) # TODO
1410     self.rm_testdir()
1411
1412
1413   url_CVE_2017_5978 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1414   zip_CVE_2017_5978 = "00156-zziplib-oobread-zzip_mem_entry_new"
1415   def test_59780_infozipdir_CVE_2017_5978(self):
1416     """ run info-zip dir test0.zip  """
1417     tmpdir = self.testdir()
1418     filename = self.zip_CVE_2017_5978
1419     file_url = self.url_CVE_2017_5978
1420     download(file_url, filename, tmpdir)
1421     exe = self.bins("unzip")
1422     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1423         returncodes = [0, 3])
1424     self.assertIn(' missing 4608 bytes in zipfile', run.errors)
1425     self.assertIn(' attempt to seek before beginning of zipfile', run.errors)
1426     self.assertLess(len(run.output), 80)
1427     self.assertLess(len(errors(run.errors)), 430)
1428     self.rm_testdir()
1429   def test_59781_zzipdir_big_CVE_2017_5978(self):
1430     """ run info-zip -l $(CVE_2017_5978).zip  """
1431     tmpdir = self.testdir()
1432     filename = self.zip_CVE_2017_5978
1433     file_url = self.url_CVE_2017_5978
1434     download(file_url, filename, tmpdir)
1435     exe = self.bins("unzzip-big")
1436     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1437         returncodes = [0])
1438     self.assertLess(len(run.output), 30)
1439     self.assertLess(len(errors(run.errors)), 1)
1440     self.assertIn(" stored (null)", run.output)
1441     self.rm_testdir()
1442   def test_59782_zzipdir_mem_CVE_2017_5978(self):
1443     """ run unzzip-mem -l $(CVE_2017_5978).zip  """
1444     tmpdir = self.testdir()
1445     filename = self.zip_CVE_2017_5978
1446     file_url = self.url_CVE_2017_5978
1447     download(file_url, filename, tmpdir)
1448     exe = self.bins("unzzip-mem")
1449     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1450         returncodes = [0])
1451     self.assertLess(len(run.output), 1)
1452     self.assertLess(len(errors(run.errors)), 180)
1453     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
1454     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
1455     self.rm_testdir()
1456   @unittest.expectedFailure
1457   def test_59783_zzipdir_mix_CVE_2017_5978(self):
1458     """ run unzzip-mix -l $(CVE_2017_5978).zip  """
1459     tmpdir = self.testdir()
1460     filename = self.zip_CVE_2017_5978
1461     file_url = self.url_CVE_2017_5978
1462     download(file_url, filename, tmpdir)
1463     exe = self.bins("unzzip-mix")
1464     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1465         returncodes = [0])
1466     self.assertLess(len(run.output), 1)
1467     self.assertLess(len(errors(run.errors)), 180)
1468     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
1469     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
1470     self.rm_testdir()
1471   @unittest.expectedFailure
1472   def test_59784_zzipdir_zap_CVE_2017_5978(self):
1473     """ run unzzip -l $(CVE_2017_5978).zip  """
1474     tmpdir = self.testdir()
1475     filename = self.zip_CVE_2017_5978
1476     file_url = self.url_CVE_2017_5978
1477     download(file_url, filename, tmpdir)
1478     exe = self.bins("unzzip")
1479     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1480         returncodes = [0, 255])
1481     self.assertLess(len(run.output), 1)
1482     self.assertLess(len(errors(run.errors)), 180)
1483     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
1484     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
1485     self.rm_testdir()
1486   def test_59785_zipext_info_CVE_2017_5978(self):
1487     """ run info' unzip $(CVE_2017_5978).zip  """
1488     tmpdir = self.testdir()
1489     filename = self.zip_CVE_2017_5978
1490     file_url = self.url_CVE_2017_5978
1491     download(file_url, filename, tmpdir)
1492     exe = self.bins("unzip")
1493     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
1494         returncodes = [3])
1495     self.assertLess(len(run.output), 90)
1496     self.assertLess(len(errors(run.errors)), 900)
1497     self.assertIn('attempt to seek before beginning of zipfile', run.errors)
1498     self.assertFalse(os.path.exists(tmpdir+"/test"))
1499     self.rm_testdir()
1500   @unittest.expectedFailure
1501   def test_59786_zzipext_big_CVE_2017_5978(self):
1502     """ run unzzip-big $(CVE_2017_5978).zip  """
1503     tmpdir = self.testdir()
1504     filename = self.zip_CVE_2017_5978
1505     file_url = self.url_CVE_2017_5978
1506     download(file_url, filename, tmpdir)
1507     exe = self.bins("unzzip-big")
1508     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1509         returncodes = [0])
1510     self.assertLess(len(run.output), 30)
1511     self.assertLess(len(errors(run.errors)), 1)
1512     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1513     self.rm_testdir()
1514   def test_59787_zzipext_mem_CVE_2017_5978(self):
1515     """ run unzzip-mem $(CVE_2017_5978).zip  """
1516     tmpdir = self.testdir()
1517     filename = self.zip_CVE_2017_5978
1518     file_url = self.url_CVE_2017_5978
1519     download(file_url, filename, tmpdir)
1520     exe = self.bins("unzzip-mem")
1521     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1522         returncodes = [0])
1523     self.assertLess(len(run.output), 30)
1524     self.assertLess(len(errors(run.errors)), 300)
1525     self.assertIn("..(nil)", run.errors)
1526     self.assertFalse(os.path.exists(tmpdir+"/test"))
1527     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1528     self.rm_testdir()
1529   def test_59788_zzipext_mix_CVE_2017_5978(self):
1530     """ run unzzip-mix $(CVE_2017_5978).zip  """
1531     tmpdir = self.testdir()
1532     filename = self.zip_CVE_2017_5978
1533     file_url = self.url_CVE_2017_5978
1534     download(file_url, filename, tmpdir)
1535     exe = self.bins("unzzip-mem")
1536     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1537         returncodes = [0])
1538     self.assertLess(len(run.output), 30)
1539     self.assertLess(len(errors(run.errors)), 300)
1540     self.assertIn("..(nil)", run.errors)
1541     self.assertFalse(os.path.exists(tmpdir+"/test"))
1542     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1543     self.rm_testdir()
1544   @unittest.expectedFailure
1545   def test_59789_zzipext_zap_CVE_2017_5978(self):
1546     """ run unzzip $(CVE_2017_5978).zip  """
1547     tmpdir = self.testdir()
1548     filename = self.zip_CVE_2017_5978
1549     file_url = self.url_CVE_2017_5978
1550     download(file_url, filename, tmpdir)
1551     exe = self.bins("unzzip")
1552     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1553         returncodes = [0])
1554     self.assertLess(len(run.output), 30)
1555     self.assertLess(len(errors(run.errors)), 300)
1556     self.assertIn("..(nil)", run.errors)
1557     self.assertFalse(os.path.exists(tmpdir+"/test"))
1558     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 0)
1559     self.rm_testdir()
1560
1561   url_CVE_2017_5979 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1562   zip_CVE_2017_5979 = "00157-zziplib-nullptr-prescan_entry"
1563   def test_59790_infozipdir_CVE_2017_5979(self):
1564     """ run info-zip dir test0.zip  """
1565     tmpdir = self.testdir()
1566     filename = self.zip_CVE_2017_5979
1567     file_url = self.url_CVE_2017_5979
1568     download(file_url, filename, tmpdir)
1569     exe = self.bins("unzip")
1570     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1571         returncodes = [0])
1572     self.assertIn(' 1 file', run.output)
1573     self.assertLess(len(run.output), 330)
1574     self.assertLess(len(errors(run.errors)), 1)
1575     self.rm_testdir()
1576   def test_59791_zzipdir_big_CVE_2017_5979(self):
1577     """ run info-zip -l $(CVE_2017_5979).zip  """
1578     tmpdir = self.testdir()
1579     filename = self.zip_CVE_2017_5979
1580     file_url = self.url_CVE_2017_5979
1581     download(file_url, filename, tmpdir)
1582     exe = self.bins("unzzip-big")
1583     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1584         returncodes = [0])
1585     self.assertLess(len(run.output), 30)
1586     self.assertLess(len(errors(run.errors)), 1)
1587     self.assertIn(" stored a", run.output)
1588     self.rm_testdir()
1589   def test_59792_zzipdir_mem_CVE_2017_5979(self):
1590     """ run unzzip-mem -l $(CVE_2017_5979).zip  """
1591     tmpdir = self.testdir()
1592     filename = self.zip_CVE_2017_5979
1593     file_url = self.url_CVE_2017_5979
1594     download(file_url, filename, tmpdir)
1595     exe = self.bins("unzzip-mem")
1596     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1597         returncodes = [0])
1598     self.assertLess(len(run.output), 30)
1599     self.assertLess(len(errors(run.errors)), 1)
1600     self.assertIn(" 3 a", run.output)
1601     self.rm_testdir()
1602   def test_59793_zzipdir_mix_CVE_2017_5979(self):
1603     """ run unzzip-mix -l $(CVE_2017_5979).zip  """
1604     tmpdir = self.testdir()
1605     filename = self.zip_CVE_2017_5979
1606     file_url = self.url_CVE_2017_5979
1607     download(file_url, filename, tmpdir)
1608     exe = self.bins("unzzip-mix")
1609     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1610         returncodes = [0])
1611     self.assertLess(len(run.output), 30)
1612     self.assertLess(len(errors(run.errors)), 1)
1613     self.assertIn(" 3 a", run.output)
1614     self.rm_testdir()
1615   def test_59794_zzipdir_zap_CVE_2017_5979(self):
1616     """ run unzzip -l $(CVE_2017_5979).zip  """
1617     tmpdir = self.testdir()
1618     filename = self.zip_CVE_2017_5979
1619     file_url = self.url_CVE_2017_5979
1620     download(file_url, filename, tmpdir)
1621     exe = self.bins("unzzip")
1622     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1623         returncodes = [0, 255])
1624     self.assertLess(len(run.output), 30)
1625     self.assertLess(len(errors(run.errors)), 1)
1626     self.assertIn(" 3 a", run.output)
1627     self.rm_testdir()
1628   def test_59795_zipext_info_CVE_2017_5979(self):
1629     """ run info' unzip $(CVE_2017_5979).zip  """
1630     tmpdir = self.testdir()
1631     filename = self.zip_CVE_2017_5979
1632     file_url = self.url_CVE_2017_5979
1633     download(file_url, filename, tmpdir)
1634     exe = self.bins("unzip")
1635     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
1636         returncodes = [0])
1637     self.assertLess(len(run.output), 90)
1638     self.assertLess(len(errors(run.errors)), 1)
1639     self.assertIn('extracting: a', run.output)
1640     self.assertEqual(os.path.getsize(tmpdir+"/a"), 3)
1641     self.rm_testdir()
1642   def test_59796_zzipext_big_CVE_2017_5979(self):
1643     """ run unzzip-big $(CVE_2017_5979).zip  """
1644     tmpdir = self.testdir()
1645     filename = self.zip_CVE_2017_5979
1646     file_url = self.url_CVE_2017_5979
1647     download(file_url, filename, tmpdir)
1648     exe = self.bins("unzzip-big")
1649     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1650         returncodes = [0])
1651     self.assertLess(len(run.output), 30)
1652     self.assertLess(len(errors(run.errors)), 1)
1653     self.assertEqual(os.path.getsize(tmpdir+"/a"), 3)
1654     self.rm_testdir()
1655   @unittest.expectedFailure
1656   def test_59797_zzipext_mem_CVE_2017_5979(self):
1657     """ run unzzip-mem $(CVE_2017_5979).zip  """
1658     tmpdir = self.testdir()
1659     filename = self.zip_CVE_2017_5979
1660     file_url = self.url_CVE_2017_5979
1661     download(file_url, filename, tmpdir)
1662     exe = self.bins("unzzip-mem")
1663     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1664         returncodes = [0])
1665     self.assertLess(len(run.output), 30)
1666     self.assertLess(len(errors(run.errors)), 1)
1667     self.assertEqual(os.path.getsize(tmpdir+"/a"), 3)
1668     self.rm_testdir()
1669   @unittest.expectedFailure
1670   def test_59798_zzipext_mix_CVE_2017_5979(self):
1671     """ run unzzip-mix $(CVE_2017_5979).zip  """
1672     tmpdir = self.testdir()
1673     filename = self.zip_CVE_2017_5979
1674     file_url = self.url_CVE_2017_5979
1675     download(file_url, filename, tmpdir)
1676     exe = self.bins("unzzip-mix")
1677     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1678         returncodes = [0])
1679     self.assertLess(len(run.output), 30)
1680     self.assertLess(len(errors(run.errors)), 20)
1681     self.assertEqual(os.path.getsize(tmpdir+"/a"), 3)
1682     self.rm_testdir()
1683   # @unittest.expectedFailure
1684   def test_59799_zzipext_zap_CVE_2017_5979(self):
1685     """ run unzzip-mix $(CVE_2017_5979).zip  """
1686     tmpdir = self.testdir()
1687     filename = self.zip_CVE_2017_5979
1688     file_url = self.url_CVE_2017_5979
1689     download(file_url, filename, tmpdir)
1690     exe = self.bins("unzzip")
1691     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1692         returncodes = [0])
1693     self.assertLess(len(run.output), 30)
1694     self.assertLess(len(errors(run.errors)), 20)
1695     self.assertEqual(os.path.getsize(tmpdir+"/a"), 3)
1696     self.rm_testdir()
1697
1698
1699   url_CVE_2017_5974 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1700   zip_CVE_2017_5974 = "00150-zziplib-heapoverflow-__zzip_get32"
1701   def test_59740_infozipdir_CVE_2017_5974(self):
1702     """ run info-zip dir test0.zip  """
1703     tmpdir = self.testdir()
1704     filename = self.zip_CVE_2017_5974
1705     file_url = self.url_CVE_2017_5974
1706     download(file_url, filename, tmpdir)
1707     exe = self.bins("unzip")
1708     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1709         returncodes = [0, 9])
1710     self.assertIn(' 1 file', run.output)
1711     self.assertLess(len(run.output), 330)
1712     self.assertLess(len(errors(run.errors)), 1)
1713     self.rm_testdir()
1714   def test_59741_zzipdir_big_CVE_2017_5974(self):
1715     """ run unzzip-big -l $(CVE_2017_5974).zip  """
1716     tmpdir = self.testdir()
1717     filename = self.zip_CVE_2017_5974
1718     file_url = self.url_CVE_2017_5974
1719     download(file_url, filename, tmpdir)
1720     exe = self.bins("unzzip-big")
1721     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1722         returncodes = [0])
1723     self.assertLess(len(run.output), 30)
1724     self.assertLess(len(errors(run.errors)), 1)
1725     self.assertIn(" stored test", run.output)
1726     self.rm_testdir()
1727   def test_59742_zzipdir_mem_CVE_2017_5974(self):
1728     """ run unzzip-mem -l $(CVE_2017_5974).zip  """
1729     tmpdir = self.testdir()
1730     filename = self.zip_CVE_2017_5974
1731     file_url = self.url_CVE_2017_5974
1732     download(file_url, filename, tmpdir)
1733     exe = self.bins("unzzip-mem")
1734     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1735         returncodes = [0])
1736     self.assertLess(len(run.output), 30)
1737     self.assertLess(len(errors(run.errors)), 1)
1738     self.assertIn(" 3 test", run.output)
1739     self.rm_testdir()
1740   @unittest.expectedFailure
1741   def test_59743_zzipdir_mix_CVE_2017_5974(self):
1742     """ run unzzip-mix -l $(CVE_2017_5974).zip  """
1743     tmpdir = self.testdir()
1744     filename = self.zip_CVE_2017_5974
1745     file_url = self.url_CVE_2017_5974
1746     download(file_url, filename, tmpdir)
1747     exe = self.bins("unzzip-mix")
1748     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1749         returncodes = [0])
1750     self.assertLess(len(run.output), 30)
1751     self.assertLess(len(errors(run.errors)), 1)
1752     self.assertIn(" 3 test", run.output)
1753     self.rm_testdir()
1754   def test_59744_zzipdir_zap_CVE_2017_5974(self):
1755     """ run unzzip -l $(CVE_2017_5974).zip  """
1756     tmpdir = self.testdir()
1757     filename = self.zip_CVE_2017_5974
1758     file_url = self.url_CVE_2017_5974
1759     download(file_url, filename, tmpdir)
1760     exe = self.bins("unzzip")
1761     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1762         returncodes = [0, 255])
1763     self.assertLess(len(run.output), 30)
1764     self.assertLess(len(errors(run.errors)), 1)
1765     self.assertIn(" 3 test", run.output)
1766     self.rm_testdir()
1767   def test_59745_zzipext_zip_CVE_2017_5974(self):
1768     """ run info' unzip $(CVE_2017_5974).zip  """
1769     tmpdir = self.testdir()
1770     filename = self.zip_CVE_2017_5974
1771     file_url = self.url_CVE_2017_5974
1772     download(file_url, filename, tmpdir)
1773     exe = self.bins("unzip")
1774     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
1775         returncodes = [0])
1776     self.assertLess(len(run.output), 90)
1777     self.assertLess(len(errors(run.errors)), 1)
1778     self.assertIn(" extracting: test", run.output)
1779     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1780     self.rm_testdir()
1781   def test_59746_zzipext_big_CVE_2017_5974(self):
1782     """ run unzzip-big $(CVE_2017_5974).zip  """
1783     tmpdir = self.testdir()
1784     filename = self.zip_CVE_2017_5974
1785     file_url = self.url_CVE_2017_5974
1786     download(file_url, filename, tmpdir)
1787     exe = self.bins("unzzip-big")
1788     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1789         returncodes = [0])
1790     self.assertLess(len(run.output), 30)
1791     self.assertLess(len(errors(run.errors)), 1)
1792     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1793     self.rm_testdir()
1794   @unittest.expectedFailure
1795   def test_59747_zzipext_mem_CVE_2017_5974(self):
1796     """ run unzzip-mem $(CVE_2017_5974).zip  """
1797     tmpdir = self.testdir()
1798     filename = self.zip_CVE_2017_5974
1799     file_url = self.url_CVE_2017_5974
1800     download(file_url, filename, tmpdir)
1801     exe = self.bins("unzzip-mem")
1802     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1803         returncodes = [0])
1804     self.assertLess(len(run.output), 30)
1805     self.assertLess(len(errors(run.errors)), 1)
1806     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1807     self.rm_testdir()
1808   @unittest.expectedFailure
1809   def test_59748_zzipext_mix_CVE_2017_5974(self):
1810     """ run unzzip-mix $(CVE_2017_5974).zip  """
1811     tmpdir = self.testdir()
1812     filename = self.zip_CVE_2017_5974
1813     file_url = self.url_CVE_2017_5974
1814     download(file_url, filename, tmpdir)
1815     exe = self.bins("unzzip-mix")
1816     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1817         returncodes = [0])
1818     self.assertLess(len(run.output), 30)
1819     self.assertLess(len(errors(run.errors)), 1)
1820     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1821     self.rm_testdir()
1822   def test_59749_zzipext_zap_CVE_2017_5974(self):
1823     """ run unzzip $(CVE_2017_5974).zip  """
1824     tmpdir = self.testdir()
1825     filename = self.zip_CVE_2017_5974
1826     file_url = self.url_CVE_2017_5974
1827     download(file_url, filename, tmpdir)
1828     exe = self.bins("unzzip")
1829     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1830         returncodes = [0])
1831     self.assertLess(len(run.output), 30)
1832     self.assertLess(len(errors(run.errors)), 1)
1833     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1834     self.rm_testdir()
1835
1836   url_CVE_2017_5975 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1837   zip_CVE_2017_5975 = "00151-zziplib-heapoverflow-__zzip_get64"
1838   def test_59750_infozipdir_CVE_2017_5975(self):
1839     """ run info-zip dir test0.zip  """
1840     tmpdir = self.testdir()
1841     filename = self.zip_CVE_2017_5975
1842     file_url = self.url_CVE_2017_5975
1843     download(file_url, filename, tmpdir)
1844     exe = self.bins("unzip")
1845     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1846         returncodes = [0, 2])
1847     self.assertIn(' missing 10 bytes in zipfile', run.errors)
1848     self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors)
1849     self.assertIn(' 1 file', run.output)
1850     self.assertLess(len(run.output), 330)
1851     self.assertLess(len(errors(run.errors)), 430)
1852     self.rm_testdir()
1853   def test_59751_zzipdir_big_CVE_2017_5975(self):
1854     """ run info-zip -l $(CVE_2017_5975).zip  """
1855     tmpdir = self.testdir()
1856     filename = self.zip_CVE_2017_5975
1857     file_url = self.url_CVE_2017_5975
1858     download(file_url, filename, tmpdir)
1859     exe = self.bins("unzzip-big")
1860     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1861         returncodes = [0])
1862     self.assertLess(len(run.output), 30)
1863     self.assertLess(len(errors(run.errors)), 1)
1864     self.assertIn(" stored test", run.output)
1865     self.rm_testdir()
1866   def test_59752_zzipdir_mem_CVE_2017_5975(self):
1867     """ run unzzip-mem -l $(CVE_2017_5975).zip  """
1868     tmpdir = self.testdir()
1869     filename = self.zip_CVE_2017_5975
1870     file_url = self.url_CVE_2017_5975
1871     download(file_url, filename, tmpdir)
1872     exe = self.bins("unzzip-mem")
1873     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1874         returncodes = [0])
1875     self.assertLess(len(run.output), 1)
1876     self.assertLess(len(errors(run.errors)), 180)
1877     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
1878     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
1879     self.rm_testdir()
1880   def test_59753_zzipdir_mix_CVE_2017_5975(self):
1881     """ run unzzip-mix -l $(CVE_2017_5975).zip  """
1882     tmpdir = self.testdir()
1883     filename = self.zip_CVE_2017_5975
1884     file_url = self.url_CVE_2017_5975
1885     download(file_url, filename, tmpdir)
1886     exe = self.bins("unzzip-mix")
1887     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1888         returncodes = [0])
1889     self.assertLess(len(run.output), 1)
1890     self.assertLess(len(errors(run.errors)), 180)
1891     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
1892     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
1893     self.rm_testdir()
1894   def test_59754_zzipdir_zap_CVE_2017_5975(self):
1895     """ run unzzip -l $(CVE_2017_5975).zip  """
1896     tmpdir = self.testdir()
1897     filename = self.zip_CVE_2017_5975
1898     file_url = self.url_CVE_2017_5975
1899     download(file_url, filename, tmpdir)
1900     exe = self.bins("unzzip")
1901     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1902         returncodes = [0, 255])
1903     self.assertLess(len(run.output), 1)
1904     self.assertLess(len(errors(run.errors)), 180)
1905     self.assertIn(": Success", run.errors)
1906     self.rm_testdir()
1907   def test_59755_zipext_info_CVE_2017_5975(self):
1908     """ run info' unzip $(CVE_2017_5975).zip  """
1909     tmpdir = self.testdir()
1910     filename = self.zip_CVE_2017_5975
1911     file_url = self.url_CVE_2017_5975
1912     download(file_url, filename, tmpdir)
1913     exe = self.bins("unzip")
1914     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
1915         returncodes = [2])
1916     self.assertLess(len(run.output), 90)
1917     self.assertLess(len(errors(run.errors)), 900)
1918     self.assertIn('file #1:  bad zipfile offset (local header sig):  127', run.errors)
1919     #self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
1920     self.assertFalse(os.path.exists(tmpdir+"/test"))
1921     self.rm_testdir()
1922   def test_59756_zzipext_big_CVE_2017_5975(self):
1923     """ run unzzip-big $(CVE_2017_5975).zip  """
1924     tmpdir = self.testdir()
1925     filename = self.zip_CVE_2017_5975
1926     file_url = self.url_CVE_2017_5975
1927     download(file_url, filename, tmpdir)
1928     exe = self.bins("unzzip-big")
1929     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1930         returncodes = [0])
1931     self.assertLess(len(run.output), 30)
1932     self.assertLess(len(errors(run.errors)), 1)
1933     self.assertEqual(os.path.getsize(tmpdir+"/test"), 0) # TODO
1934     self.rm_testdir()
1935   def test_59757_zzipext_mem_CVE_2017_5975(self):
1936     """ run unzzip-mem $(CVE_2017_5975).zip  """
1937     tmpdir = self.testdir()
1938     filename = self.zip_CVE_2017_5975
1939     file_url = self.url_CVE_2017_5975
1940     download(file_url, filename, tmpdir)
1941     exe = self.bins("unzzip-mem")
1942     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1943         returncodes = [0])
1944     self.assertLess(len(run.output), 30)
1945     self.assertLess(len(errors(run.errors)), 200)
1946     self.assertIn("..(nil)", run.errors)
1947     self.assertFalse(os.path.exists(tmpdir+"/test"))
1948     self.rm_testdir()
1949   @unittest.expectedFailure
1950   def test_59758_zzipext_mix_CVE_2017_5975(self):
1951     """ run unzzip-mix $(CVE_2017_5975).zip  """
1952     tmpdir = self.testdir()
1953     filename = self.zip_CVE_2017_5975
1954     file_url = self.url_CVE_2017_5975
1955     download(file_url, filename, tmpdir)
1956     exe = self.bins("unzzip-mix")
1957     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1958         returncodes = [0])
1959     self.assertLess(len(run.output), 30)
1960     self.assertLess(len(errors(run.errors)), 200)
1961     self.assertIn("..(nil)", run.errors)
1962     self.assertFalse(os.path.exists(tmpdir+"/test"))
1963     self.rm_testdir()
1964   @unittest.expectedFailure
1965   def test_59759_zzipext_zap_CVE_2017_5975(self):
1966     """ run unzzip $(CVE_2017_5975).zip  """
1967     tmpdir = self.testdir()
1968     filename = self.zip_CVE_2017_5975
1969     file_url = self.url_CVE_2017_5975
1970     download(file_url, filename, tmpdir)
1971     exe = self.bins("unzzip")
1972     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
1973         returncodes = [0])
1974     self.assertLess(len(run.output), 30)
1975     self.assertLess(len(errors(run.errors)), 200)
1976     self.assertIn("..(nil)", run.errors)
1977     self.assertFalse(os.path.exists(tmpdir+"/test"))
1978     self.rm_testdir()
1979
1980
1981   url_CVE_2017_5976 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
1982   zip_CVE_2017_5976 = "00152-zziplib-heapoverflow-zzip_mem_entry_extra_block"
1983   def test_59760_infozipdir_CVE_2017_5976(self):
1984     """ run info-zip dir test0.zip  """
1985     tmpdir = self.testdir()
1986     filename = self.zip_CVE_2017_5976
1987     file_url = self.url_CVE_2017_5976
1988     download(file_url, filename, tmpdir)
1989     exe = self.bins("unzip")
1990     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
1991         returncodes = [0, 2])
1992     self.assertIn(' 27 extra bytes at beginning or within zipfile', run.errors)
1993     self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors)
1994     self.assertIn(' 1 file', run.output)
1995     self.assertLess(len(run.output), 330)
1996     self.assertLess(len(errors(run.errors)), 500)
1997     self.rm_testdir()
1998   def test_59761_zzipdir_big_CVE_2017_5976(self):
1999     """ run info-zip -l $(CVE_2017_5976).zip  """
2000     tmpdir = self.testdir()
2001     filename = self.zip_CVE_2017_5976
2002     file_url = self.url_CVE_2017_5976
2003     download(file_url, filename, tmpdir)
2004     exe = self.bins("unzzip-big")
2005     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2006         returncodes = [0])
2007     self.assertLess(len(run.output), 30)
2008     self.assertLess(len(errors(run.errors)), 1)
2009     self.assertIn(" stored test", run.output)
2010     self.rm_testdir()
2011   def test_59762_zzipdir_mem_CVE_2017_5976(self):
2012     """ run unzzip-mem -l $(CVE_2017_5976).zip  """
2013     tmpdir = self.testdir()
2014     filename = self.zip_CVE_2017_5976
2015     file_url = self.url_CVE_2017_5976
2016     download(file_url, filename, tmpdir)
2017     exe = self.bins("unzzip-mem")
2018     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2019         returncodes = [0])
2020     self.assertLess(len(run.output), 30)
2021     self.assertLess(len(errors(run.errors)), 1)
2022     self.assertIn("3 test", run.output)
2023     self.rm_testdir()
2024   def test_59763_zzipdir_mix_CVE_2017_5976(self):
2025     """ run unzzip-mix -l $(CVE_2017_5976).zip  """
2026     tmpdir = self.testdir()
2027     filename = self.zip_CVE_2017_5976
2028     file_url = self.url_CVE_2017_5976
2029     download(file_url, filename, tmpdir)
2030     exe = self.bins("unzzip-mix")
2031     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2032         returncodes = [0])
2033     self.assertLess(len(run.output), 30)
2034     self.assertLess(len(errors(run.errors)), 1)
2035     self.assertIn("3 test", run.output)
2036     self.rm_testdir()
2037   def test_59764_zzipdir_zap_CVE_2017_5976(self):
2038     """ run unzzip -l $(CVE_2017_5976).zip  """
2039     tmpdir = self.testdir()
2040     filename = self.zip_CVE_2017_5976
2041     file_url = self.url_CVE_2017_5976
2042     download(file_url, filename, tmpdir)
2043     exe = self.bins("unzzip")
2044     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2045         returncodes = [0, 255])
2046     self.assertLess(len(run.output), 30)
2047     self.assertLess(len(errors(run.errors)), 1)
2048     self.assertIn("3 test", run.output)
2049     self.rm_testdir()
2050   def test_59765_zipext_info_CVE_2017_5976(self):
2051     """ run info' unzip $(CVE_2017_5976).zip  """
2052     tmpdir = self.testdir()
2053     filename = self.zip_CVE_2017_5976
2054     file_url = self.url_CVE_2017_5976
2055     download(file_url, filename, tmpdir)
2056     exe = self.bins("unzip")
2057     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2058         returncodes = [2])
2059     self.assertLess(len(run.output), 190)
2060     self.assertLess(len(errors(run.errors)), 900)
2061     self.assertIn("extracting: test", run.output)
2062     self.assertIn('-27 bytes too long', run.errors)
2063     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2064     # self.assertFalse(os.path.exists(tmpdir+"/test"))
2065     self.rm_testdir()
2066   def test_59766_zzipext_big_CVE_2017_5976(self):
2067     """ run unzzip-big $(CVE_2017_5976).zip  """
2068     tmpdir = self.testdir()
2069     filename = self.zip_CVE_2017_5976
2070     file_url = self.url_CVE_2017_5976
2071     download(file_url, filename, tmpdir)
2072     exe = self.bins("unzzip-big")
2073     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2074         returncodes = [0])
2075     self.assertLess(len(run.output), 30)
2076     self.assertLess(len(errors(run.errors)), 1)
2077     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2078     self.rm_testdir()
2079   def test_59767_zzipext_mem_CVE_2017_5976(self):
2080     """ run unzzip-mem $(CVE_2017_5976).zip  """
2081     tmpdir = self.testdir()
2082     filename = self.zip_CVE_2017_5976
2083     file_url = self.url_CVE_2017_5976
2084     download(file_url, filename, tmpdir)
2085     exe = self.bins("unzzip-mem")
2086     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2087         returncodes = [0])
2088     self.assertLess(len(run.output), 30)
2089     self.assertLess(len(errors(run.errors)), 30) # TODO
2090     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2091     self.rm_testdir()
2092   @unittest.expectedFailure
2093   def test_59768_zzipext_mix_CVE_2017_5976(self):
2094     """ run unzzip-mix $(CVE_2017_5976).zip  """
2095     tmpdir = self.testdir()
2096     filename = self.zip_CVE_2017_5976
2097     file_url = self.url_CVE_2017_5976
2098     download(file_url, filename, tmpdir)
2099     exe = self.bins("unzzip-mix")
2100     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2101         returncodes = [0])
2102     self.assertLess(len(run.output), 30)
2103     self.assertLess(len(errors(run.errors)), 30) # TODO
2104     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2105     self.rm_testdir()
2106   def test_59769_zzipext_zap_CVE_2017_5976(self):
2107     """ run unzzip $(CVE_2017_5976).zip  """
2108     tmpdir = self.testdir()
2109     filename = self.zip_CVE_2017_5976
2110     file_url = self.url_CVE_2017_5976
2111     download(file_url, filename, tmpdir)
2112     exe = self.bins("unzzip")
2113     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2114         returncodes = [0])
2115     self.assertLess(len(run.output), 30)
2116     self.assertLess(len(errors(run.errors)), 30)
2117     self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2118     self.rm_testdir()
2119
2120   url_CVE_2017_5980 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
2121   zip_CVE_2017_5980 = "00154-zziplib-nullptr-zzip_mem_entry_new"
2122   def test_59800_infozipdir_CVE_2017_5980(self):
2123     """ run info-zip dir test0.zip  """
2124     tmpdir = self.testdir()
2125     filename = self.zip_CVE_2017_5980
2126     file_url = self.url_CVE_2017_5980
2127     download(file_url, filename, tmpdir)
2128     exe = self.bins("unzip")
2129     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2130         returncodes = [0, 2])
2131     self.assertIn(' missing 6 bytes in zipfile', run.errors)
2132     self.assertIn("didn't find end-of-central-dir signature at end of central dir", run.errors)
2133     self.assertIn(' 1 file', run.output)
2134     self.assertLess(len(run.output), 330)
2135     self.assertLess(len(errors(run.errors)), 500)
2136     self.rm_testdir()
2137   def test_59801_zzipdir_big_CVE_2017_5980(self):
2138     """ run info-zip -l $(CVE_2017_5980).zip  """
2139     tmpdir = self.testdir()
2140     filename = self.zip_CVE_2017_5980
2141     file_url = self.url_CVE_2017_5980
2142     download(file_url, filename, tmpdir)
2143     exe = self.bins("unzzip-big")
2144     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2145         returncodes = [0])
2146     self.assertLess(len(run.output), 30)
2147     self.assertLess(len(errors(run.errors)), 1)
2148     self.assertIn(" stored (null)", run.output)
2149     self.rm_testdir()
2150   def test_59802_zzipdir_mem_CVE_2017_5980(self):
2151     """ run unzzip-mem -l $(CVE_2017_5980).zip  """
2152     tmpdir = self.testdir()
2153     filename = self.zip_CVE_2017_5980
2154     file_url = self.url_CVE_2017_5980
2155     download(file_url, filename, tmpdir)
2156     exe = self.bins("unzzip-mem")
2157     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2158         returncodes = [0])
2159     self.assertLess(len(run.output), 1)
2160     self.assertLess(len(errors(run.errors)), 180)
2161     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
2162     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
2163     self.rm_testdir()
2164   @unittest.expectedFailure
2165   def test_59803_zzipdir_mix_CVE_2017_5980(self):
2166     """ run unzzip-mix -l $(CVE_2017_5980).zip  """
2167     tmpdir = self.testdir()
2168     filename = self.zip_CVE_2017_5980
2169     file_url = self.url_CVE_2017_5980
2170     download(file_url, filename, tmpdir)
2171     exe = self.bins("unzzip-mix")
2172     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2173         returncodes = [0])
2174     self.assertLess(len(run.output), 1)
2175     self.assertLess(len(errors(run.errors)), 180)
2176     self.assertIn("zzip_mem_disk_load : unable to load entry", run.errors)
2177     self.assertIn("zzip_mem_disk_open : unable to load disk", run.errors)
2178     self.rm_testdir()
2179   def test_59804_zzipdir_zap_CVE_2017_5980(self):
2180     """ run unzzip -l $(CVE_2017_5980).zip  """
2181     tmpdir = self.testdir()
2182     filename = self.zip_CVE_2017_5980
2183     file_url = self.url_CVE_2017_5980
2184     download(file_url, filename, tmpdir)
2185     exe = self.bins("unzzip")
2186     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2187         returncodes = [0, 255])
2188     self.assertLess(len(run.output), 1)
2189     self.assertLess(len(errors(run.errors)), 180)
2190     self.assertIn(": Success", run.errors)
2191     self.rm_testdir()
2192   def test_59805_zipext_info_CVE_2017_5980(self):
2193     """ run info' unzip $(CVE_2017_5980).zip  """
2194     tmpdir = self.testdir()
2195     filename = self.zip_CVE_2017_5980
2196     file_url = self.url_CVE_2017_5980
2197     download(file_url, filename, tmpdir)
2198     exe = self.bins("unzip")
2199     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2200         returncodes = [3])
2201     self.assertLess(len(run.output), 90)
2202     self.assertLess(len(errors(run.errors)), 900)
2203     self.assertIn('file #1:  bad zipfile offset (lseek)', run.errors)
2204     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2205     self.assertFalse(os.path.exists(tmpdir+"/test"))
2206     self.rm_testdir()
2207   @unittest.expectedFailure
2208   def test_59806_zzipext_big_CVE_2017_5980(self):
2209     """ run unzzip-big $(CVE_2017_5980).zip  """
2210     tmpdir = self.testdir()
2211     filename = self.zip_CVE_2017_5980
2212     file_url = self.url_CVE_2017_5980
2213     download(file_url, filename, tmpdir)
2214     exe = self.bins("unzzip-big")
2215     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2216         returncodes = [0])
2217     self.assertLess(len(run.output), 30)
2218     self.assertLess(len(errors(run.errors)), 1)
2219     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2220     self.assertFalse(os.path.exists(tmpdir+"/test"))
2221     self.rm_testdir()
2222   def test_59807_zzipext_mem_CVE_2017_5980(self):
2223     """ run unzzip-mem $(CVE_2017_5980).zip  """
2224     tmpdir = self.testdir()
2225     filename = self.zip_CVE_2017_5980
2226     file_url = self.url_CVE_2017_5980
2227     download(file_url, filename, tmpdir)
2228     exe = self.bins("unzzip-mem")
2229     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2230         returncodes = [0])
2231     self.assertLess(len(run.output), 30)
2232     self.assertLess(len(errors(run.errors)), 200)
2233     self.assertFalse(os.path.exists(tmpdir+"/test"))
2234     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2235     self.rm_testdir()
2236   @unittest.expectedFailure
2237   def test_59808_zzipext_mix_CVE_2017_5980(self):
2238     """ run unzzip-mix $(CVE_2017_5980).zip  """
2239     tmpdir = self.testdir()
2240     filename = self.zip_CVE_2017_5980
2241     file_url = self.url_CVE_2017_5980
2242     download(file_url, filename, tmpdir)
2243     exe = self.bins("unzzip-mix")
2244     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2245         returncodes = [0])
2246     self.assertLess(len(run.output), 30)
2247     self.assertLess(len(errors(run.errors)), 200)
2248     self.assertFalse(os.path.exists(tmpdir+"/test"))
2249     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2250     self.rm_testdir()
2251   def test_59809_zzipext_zap_CVE_2017_5980(self):
2252     """ run unzzip $(CVE_2017_5980).zip  """
2253     tmpdir = self.testdir()
2254     filename = self.zip_CVE_2017_5980
2255     file_url = self.url_CVE_2017_5980
2256     download(file_url, filename, tmpdir)
2257     exe = self.bins("unzzip")
2258     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2259         returncodes = [255]) # TODO
2260     self.assertLess(len(run.output), 30)
2261     self.assertLess(len(errors(run.errors)), 200)
2262     self.assertFalse(os.path.exists(tmpdir+"/test"))
2263     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2264     self.rm_testdir()
2265
2266   url_CVE_2017_5981 = "https://raw.githubusercontent.com/asarubbo/poc/master/"
2267   zip_CVE_2017_5981 = "00161-zziplib-assertionfailure-seeko_C"
2268   def test_59810_infozipdir_CVE_2017_5981(self):
2269     """ run info-zip dir test0.zip  """
2270     tmpdir = self.testdir()
2271     filename = self.zip_CVE_2017_5981
2272     file_url = self.url_CVE_2017_5981
2273     download(file_url, filename, tmpdir)
2274     exe = self.bins("unzip")
2275     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2276         returncodes = [0, 3])
2277     self.assertIn(' missing 4 bytes in zipfile', run.errors)
2278     self.assertIn("zipfile corrupt", run.errors)
2279     self.assertLess(len(run.output), 80)
2280     self.assertLess(len(errors(run.errors)), 500)
2281     self.rm_testdir()
2282   def test_59811_zzipdir_big_CVE_2017_5981(self):
2283     """ run info-zip -l $(CVE_2017_5981).zip  """
2284     tmpdir = self.testdir()
2285     filename = self.zip_CVE_2017_5981
2286     file_url = self.url_CVE_2017_5981
2287     download(file_url, filename, tmpdir)
2288     exe = self.bins("unzzip-big")
2289     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2290         returncodes = [0])
2291     self.assertLess(len(run.output), 1)
2292     self.assertLess(len(errors(run.errors)), 1)
2293     self.rm_testdir()
2294   def test_59812_zzipdir_mem_CVE_2017_5981(self):
2295     """ run unzzip-mem -l $(CVE_2017_5981).zip  """
2296     tmpdir = self.testdir()
2297     filename = self.zip_CVE_2017_5981
2298     file_url = self.url_CVE_2017_5981
2299     download(file_url, filename, tmpdir)
2300     exe = self.bins("unzzip-mem")
2301     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2302         returncodes = [0])
2303     self.assertLess(len(run.output), 1)
2304     self.assertLess(len(errors(run.errors)), 1)
2305     self.rm_testdir()
2306   def test_59813_zzipdir_mix_CVE_2017_5981(self):
2307     """ run unzzip-mix -l $(CVE_2017_5981).zip  """
2308     tmpdir = self.testdir()
2309     filename = self.zip_CVE_2017_5981
2310     file_url = self.url_CVE_2017_5981
2311     download(file_url, filename, tmpdir)
2312     exe = self.bins("unzzip-mix")
2313     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2314         returncodes = [0])
2315     self.assertLess(len(run.output), 1)
2316     self.assertLess(len(errors(run.errors)), 1)
2317     self.rm_testdir()
2318   def test_59814_zzipdir_zap_CVE_2017_5981(self):
2319     """ run unzzip-zap -l $(CVE_2017_5981).zip  """
2320     tmpdir = self.testdir()
2321     filename = self.zip_CVE_2017_5981
2322     file_url = self.url_CVE_2017_5981
2323     download(file_url, filename, tmpdir)
2324     exe = self.bins("unzzip")
2325     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2326         returncodes = [0, 255])
2327     self.assertLess(len(run.output), 1)
2328     self.assertLess(len(errors(run.errors)), 80)
2329     self.assertIn(": Success", run.errors)
2330     self.rm_testdir()
2331   def test_59815_zipext_info_CVE_2017_5981(self):
2332     """ run info' unzip $(CVE_2017_5981).zip  """
2333     tmpdir = self.testdir()
2334     filename = self.zip_CVE_2017_5981
2335     file_url = self.url_CVE_2017_5981
2336     download(file_url, filename, tmpdir)
2337     exe = self.bins("unzip")
2338     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2339         returncodes = [3])
2340     self.assertLess(len(run.output), 90)
2341     self.assertLess(len(errors(run.errors)), 500)
2342     self.assertIn('zipfile corrupt.', run.errors)
2343     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2344     self.assertFalse(os.path.exists(tmpdir+"/test"))
2345     self.rm_testdir()
2346   def test_59816_zzipext_big_CVE_2017_5981(self):
2347     """ run unzzip-big $(CVE_2017_5981).zip  """
2348     tmpdir = self.testdir()
2349     filename = self.zip_CVE_2017_5981
2350     file_url = self.url_CVE_2017_5981
2351     download(file_url, filename, tmpdir)
2352     exe = self.bins("unzzip-big")
2353     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2354         returncodes = [0])
2355     self.assertLess(len(run.output), 30)
2356     self.assertLess(len(errors(run.errors)), 1)
2357     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2358     self.assertFalse(os.path.exists(tmpdir+"/test"))
2359     self.rm_testdir()
2360   def test_59817_zzipext_mem_CVE_2017_5981(self):
2361     """ run unzzip-mem $(CVE_2017_5981).zip  """
2362     tmpdir = self.testdir()
2363     filename = self.zip_CVE_2017_5981
2364     file_url = self.url_CVE_2017_5981
2365     download(file_url, filename, tmpdir)
2366     exe = self.bins("unzzip-mem")
2367     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2368         returncodes = [0])
2369     self.assertLess(len(run.output), 30)
2370     self.assertLess(len(errors(run.errors)), 10)
2371     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2372     self.assertFalse(os.path.exists(tmpdir+"/test"))
2373     self.rm_testdir()
2374   @unittest.expectedFailure
2375   def test_59818_zzipext_mix_CVE_2017_5981(self):
2376     """ run unzzip-mix $(CVE_2017_5981).zip  """
2377     tmpdir = self.testdir()
2378     filename = self.zip_CVE_2017_5981
2379     file_url = self.url_CVE_2017_5981
2380     download(file_url, filename, tmpdir)
2381     exe = self.bins("unzzip-mix")
2382     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2383         returncodes = [0])
2384     self.assertLess(len(run.output), 30)
2385     self.assertLess(len(errors(run.errors)), 10)
2386     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2387     self.assertFalse(os.path.exists(tmpdir+"/test"))
2388     self.rm_testdir()
2389   @unittest.expectedFailure
2390   def test_59819_zzipext_zap_CVE_2017_5981(self):
2391     """ run unzzip $(CVE_2017_5981).zip  """
2392     tmpdir = self.testdir()
2393     filename = self.zip_CVE_2017_5981
2394     file_url = self.url_CVE_2017_5981
2395     download(file_url, filename, tmpdir)
2396     exe = self.bins("unzzip")
2397     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2398         returncodes = [0])
2399     self.assertLess(len(run.output), 30)
2400     self.assertLess(len(errors(run.errors)), 10)
2401     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2402     self.assertFalse(os.path.exists(tmpdir+"/test"))
2403     self.rm_testdir()
2404
2405
2406   url_CVE_2018_10 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
2407   zip_CVE_2018_10 = "zziplib_0-13-67_zzdir_invalid-memory-access_main.zip"
2408   def test_63010(self):
2409     """ info unzip -l $(CVE).zip  """
2410     tmpdir = self.testdir()
2411     filename = self.zip_CVE_2018_10
2412     file_url = self.url_CVE_2018_10
2413     download(file_url, filename, tmpdir)
2414     exe = self.bins("unzip")
2415     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2416         returncodes = [0, 9])
2417     self.assertIn("End-of-central-directory signature not found", run.errors)
2418     self.assertLess(len(run.output), 80)
2419     self.assertLess(len(errors(run.errors)), 600)
2420     self.rm_testdir()
2421   def test_63011(self):
2422     """ unzzip-big -l $(CVE).zip  """
2423     tmpdir = self.testdir()
2424     filename = self.zip_CVE_2018_10
2425     file_url = self.url_CVE_2018_10
2426     download(file_url, filename, tmpdir)
2427     exe = self.bins("unzzip-big")
2428     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2429         returncodes = [0])
2430     self.assertLess(len(run.output), 1)
2431     self.assertLess(len(errors(run.errors)), 1)
2432     self.rm_testdir()
2433   def test_63012(self):
2434     """ unzzip-mem -l $(CVE).zip """
2435     tmpdir = self.testdir()
2436     filename = self.zip_CVE_2018_10
2437     file_url = self.url_CVE_2018_10
2438     download(file_url, filename, tmpdir)
2439     exe = self.bins("unzzip-mem")
2440     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2441         returncodes = [0])
2442     self.assertLess(len(run.output), 1)
2443     self.assertLess(len(errors(run.errors)), 1)
2444     self.rm_testdir()
2445   @unittest.expectedFailure
2446   def test_63013(self):
2447     """ unzzip-mix -l $(CVE).zip  """
2448     tmpdir = self.testdir()
2449     filename = self.zip_CVE_2018_10
2450     file_url = self.url_CVE_2018_10
2451     download(file_url, filename, tmpdir)
2452     exe = self.bins("unzzip-mix")
2453     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2454         returncodes = [0])
2455     self.assertLess(len(run.output), 1)
2456     self.assertLess(len(errors(run.errors)), 1)
2457     self.rm_testdir()
2458   def test_63014(self):
2459     """ unzzip-zap -l $(CVE).zip  """
2460     tmpdir = self.testdir()
2461     filename = self.zip_CVE_2018_10
2462     file_url = self.url_CVE_2018_10
2463     download(file_url, filename, tmpdir)
2464     exe = self.bins("unzzip")
2465     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2466         returncodes = [0, 255])
2467     self.assertLess(len(run.output), 1)
2468     self.assertLess(len(errors(run.errors)), 80)
2469     self.assertIn(": Success", run.errors)
2470     self.rm_testdir()
2471   def test_63015(self):
2472     """ info unzip $(CVE).zip  """
2473     tmpdir = self.testdir()
2474     filename = self.zip_CVE_2018_10
2475     file_url = self.url_CVE_2018_10
2476     download(file_url, filename, tmpdir)
2477     exe = self.bins("unzip")
2478     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2479         returncodes = [9])
2480     self.assertLess(len(run.output), 90)
2481     self.assertLess(len(errors(run.errors)), 600)
2482     self.assertIn('End-of-central-directory signature not found', run.errors)
2483     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2484     self.assertFalse(os.path.exists(tmpdir+"/test"))
2485     self.rm_testdir()
2486   def test_63016(self):
2487     """ unzzip-big $(CVE).zip  """
2488     tmpdir = self.testdir()
2489     filename = self.zip_CVE_2018_10
2490     file_url = self.url_CVE_2018_10
2491     download(file_url, filename, tmpdir)
2492     exe = self.bins("unzzip-big")
2493     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2494         returncodes = [0])
2495     self.assertLess(len(run.output), 30)
2496     self.assertLess(len(errors(run.errors)), 1)
2497     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2498     self.assertFalse(os.path.exists(tmpdir+"/test"))
2499     self.rm_testdir()
2500   def test_63017(self):
2501     """ unzzip-mem $(CVE).zip  """
2502     tmpdir = self.testdir()
2503     filename = self.zip_CVE_2018_10
2504     file_url = self.url_CVE_2018_10
2505     download(file_url, filename, tmpdir)
2506     exe = self.bins("unzzip-mem")
2507     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2508         returncodes = [0])
2509     self.assertLess(len(run.output), 30)
2510     self.assertLess(len(errors(run.errors)), 10)
2511     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2512     self.assertFalse(os.path.exists(tmpdir+"/test"))
2513     self.rm_testdir()
2514   @unittest.expectedFailure
2515   def test_63018(self):
2516     """ unzzip-mix $(CVE).zip  """
2517     tmpdir = self.testdir()
2518     filename = self.zip_CVE_2018_10
2519     file_url = self.url_CVE_2018_10
2520     download(file_url, filename, tmpdir)
2521     exe = self.bins("unzzip-mix")
2522     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2523         returncodes = [0])
2524     self.assertLess(len(run.output), 30)
2525     self.assertLess(len(errors(run.errors)), 10)
2526     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2527     self.assertFalse(os.path.exists(tmpdir+"/test"))
2528     self.rm_testdir()
2529   @unittest.expectedFailure
2530   def test_63019(self):
2531     """ unzzip $(CVE).zip  """
2532     tmpdir = self.testdir()
2533     filename = self.zip_CVE_2018_10
2534     file_url = self.url_CVE_2018_10
2535     download(file_url, filename, tmpdir)
2536     exe = self.bins("unzzip")
2537     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2538         returncodes = [0])
2539     self.assertLess(len(run.output), 30)
2540     self.assertLess(len(errors(run.errors)), 10)
2541     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2542     self.assertFalse(os.path.exists(tmpdir+"/test"))
2543     self.rm_testdir()
2544
2545   url_CVE_2018_11 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
2546   zip_CVE_2018_11 = "zziplib_0-13-67_unzzip_infinite-loop_unzzip_cat_file.zip"
2547   def test_63110(self):
2548     """ info unzip -l $(CVE).zip  """
2549     tmpdir = self.testdir()
2550     filename = self.zip_CVE_2018_11
2551     file_url = self.url_CVE_2018_11
2552     download(file_url, filename, tmpdir)
2553     exe = self.bins("unzip")
2554     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2555         returncodes = [0, 9])
2556     self.assertIn("End-of-central-directory signature not found", run.errors)
2557     self.assertLess(len(run.output), 90)
2558     self.assertLess(len(errors(run.errors)), 600)
2559     self.rm_testdir()
2560   def test_63111(self):
2561     """ unzzip-big -l $(CVE).zip  """
2562     tmpdir = self.testdir()
2563     filename = self.zip_CVE_2018_11
2564     file_url = self.url_CVE_2018_11
2565     download(file_url, filename, tmpdir)
2566     exe = self.bins("unzzip-big")
2567     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2568         returncodes = [0])
2569     self.assertLess(len(run.output), 1)
2570     self.assertLess(len(errors(run.errors)), 1)
2571     self.rm_testdir()
2572   def test_63112(self):
2573     """ unzzip-mem -l $(CVE).zip """
2574     tmpdir = self.testdir()
2575     filename = self.zip_CVE_2018_11
2576     file_url = self.url_CVE_2018_11
2577     download(file_url, filename, tmpdir)
2578     exe = self.bins("unzzip-mem")
2579     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2580         returncodes = [0])
2581     self.assertLess(len(run.output), 1)
2582     self.assertLess(len(errors(run.errors)), 1)
2583     self.rm_testdir()
2584   @unittest.expectedFailure
2585   def test_63113(self):
2586     """ unzzip-mix -l $(CVE).zip  """
2587     tmpdir = self.testdir()
2588     filename = self.zip_CVE_2018_11
2589     file_url = self.url_CVE_2018_11
2590     download(file_url, filename, tmpdir)
2591     exe = self.bins("unzzip-mix")
2592     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2593         returncodes = [0])
2594     self.assertLess(len(run.output), 1)
2595     self.assertLess(len(errors(run.errors)), 1)
2596     self.rm_testdir()
2597   def test_63114(self):
2598     """ unzzip-zap -l $(CVE).zip  """
2599     tmpdir = self.testdir()
2600     filename = self.zip_CVE_2018_11
2601     file_url = self.url_CVE_2018_11
2602     download(file_url, filename, tmpdir)
2603     exe = self.bins("unzzip")
2604     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2605         returncodes = [0, 255])
2606     self.assertLess(len(run.output), 1)
2607     self.assertLess(len(errors(run.errors)), 90)
2608     self.assertIn(": Success", run.errors)
2609     self.rm_testdir()
2610   def test_63115(self):
2611     """ info unzip $(CVE).zip  """
2612     tmpdir = self.testdir()
2613     filename = self.zip_CVE_2018_11
2614     file_url = self.url_CVE_2018_11
2615     download(file_url, filename, tmpdir)
2616     exe = self.bins("unzip")
2617     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2618         returncodes = [9])
2619     self.assertLess(len(run.output), 90)
2620     self.assertLess(len(errors(run.errors)), 600)
2621     self.assertIn('End-of-central-directory signature not found', run.errors)
2622     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2623     self.assertFalse(os.path.exists(tmpdir+"/test"))
2624     self.rm_testdir()
2625   def test_63116(self):
2626     """ unzzip-big $(CVE).zip  """
2627     tmpdir = self.testdir()
2628     filename = self.zip_CVE_2018_11
2629     file_url = self.url_CVE_2018_11
2630     download(file_url, filename, tmpdir)
2631     exe = self.bins("unzzip-big")
2632     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2633         returncodes = [0])
2634     self.assertLess(len(run.output), 30)
2635     self.assertLess(len(errors(run.errors)), 1)
2636     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2637     self.assertFalse(os.path.exists(tmpdir+"/test"))
2638     self.rm_testdir()
2639   def test_63117(self):
2640     """ unzzip-mem $(CVE).zip  """
2641     tmpdir = self.testdir()
2642     filename = self.zip_CVE_2018_11
2643     file_url = self.url_CVE_2018_11
2644     download(file_url, filename, tmpdir)
2645     exe = self.bins("unzzip-mem")
2646     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2647         returncodes = [0])
2648     self.assertLess(len(run.output), 30)
2649     self.assertLess(len(errors(run.errors)), 10)
2650     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2651     self.assertFalse(os.path.exists(tmpdir+"/test"))
2652     self.rm_testdir()
2653   @unittest.expectedFailure
2654   def test_63118(self):
2655     """ unzzip-mix $(CVE).zip  """
2656     tmpdir = self.testdir()
2657     filename = self.zip_CVE_2018_11
2658     file_url = self.url_CVE_2018_11
2659     download(file_url, filename, tmpdir)
2660     exe = self.bins("unzzip-mix")
2661     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2662         returncodes = [0])
2663     self.assertLess(len(run.output), 30)
2664     self.assertLess(len(errors(run.errors)), 10)
2665     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2666     self.assertFalse(os.path.exists(tmpdir+"/test"))
2667     self.rm_testdir()
2668   # @unittest.expectedFailure
2669   def test_63119(self):
2670     """ unzzip $(CVE).zip  """
2671     tmpdir = self.testdir()
2672     filename = self.zip_CVE_2018_11
2673     file_url = self.url_CVE_2018_11
2674     download(file_url, filename, tmpdir)
2675     exe = self.bins("unzzip")
2676     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2677         returncodes = [0])
2678     self.assertLess(len(run.output), 30)
2679     self.assertLess(len(errors(run.errors)), 10)
2680     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2681     self.assertFalse(os.path.exists(tmpdir+"/test"))
2682     self.rm_testdir()
2683
2684   url_CVE_2018_12 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
2685   zip_CVE_2018_12 = "zziplib_0-13-67_unzip-mem_buffer-access-with-incorrect-length-value_zzip_disk_fread.zip"
2686   def test_63810(self):
2687     """ info unzip -l $(CVE).zip  """
2688     tmpdir = self.testdir()
2689     filename = self.zip_CVE_2018_12
2690     file_url = self.url_CVE_2018_12
2691     download(file_url, filename, tmpdir)
2692     exe = self.bins("unzip")
2693     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2694         returncodes = [0, 9])
2695     self.assertIn("End-of-central-directory signature not found", run.errors)
2696     self.assertLess(len(run.output), 200)
2697     self.assertLess(len(errors(run.errors)), 800)
2698     self.rm_testdir()
2699   def test_63811(self):
2700     """ unzzip-big -l $(CVE).zip  """
2701     tmpdir = self.testdir()
2702     filename = self.zip_CVE_2018_12
2703     file_url = self.url_CVE_2018_12
2704     download(file_url, filename, tmpdir)
2705     exe = self.bins("unzzip-big")
2706     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2707         returncodes = [0])
2708     self.assertLess(len(run.output), 1)
2709     self.assertLess(len(errors(run.errors)), 1)
2710     self.rm_testdir()
2711   def test_63812(self):
2712     """ unzzip-mem -l $(CVE).zip """
2713     tmpdir = self.testdir()
2714     filename = self.zip_CVE_2018_12
2715     file_url = self.url_CVE_2018_12
2716     download(file_url, filename, tmpdir)
2717     exe = self.bins("unzzip-mem")
2718     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2719         returncodes = [0])
2720     self.assertLess(len(run.output), 1)
2721     self.assertLess(len(errors(run.errors)), 1)
2722     self.rm_testdir()
2723   @unittest.expectedFailure
2724   def test_63813(self):
2725     """ unzzip-mix -l $(CVE).zip  """
2726     tmpdir = self.testdir()
2727     filename = self.zip_CVE_2018_12
2728     file_url = self.url_CVE_2018_12
2729     download(file_url, filename, tmpdir)
2730     exe = self.bins("unzzip-mix")
2731     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2732         returncodes = [0])
2733     self.assertLess(len(run.output), 1)
2734     self.assertLess(len(errors(run.errors)), 1)
2735     self.rm_testdir()
2736   def test_63814(self):
2737     """ unzzip-zap -l $(CVE).zip  """
2738     tmpdir = self.testdir()
2739     filename = self.zip_CVE_2018_12
2740     file_url = self.url_CVE_2018_12
2741     download(file_url, filename, tmpdir)
2742     exe = self.bins("unzzip")
2743     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2744         returncodes = [0, 255])
2745     self.assertLess(len(run.output), 1)
2746     self.assertLess(len(errors(run.errors)), 200)
2747     self.assertIn(": Success", run.errors)
2748     self.rm_testdir()
2749   def test_63815(self):
2750     """ info unzip $(CVE).zip  """
2751     tmpdir = self.testdir()
2752     filename = self.zip_CVE_2018_12
2753     file_url = self.url_CVE_2018_12
2754     download(file_url, filename, tmpdir)
2755     exe = self.bins("unzip")
2756     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2757         returncodes = [9])
2758     self.assertLess(len(run.output), 200)
2759     self.assertLess(len(errors(run.errors)), 800)
2760     self.assertIn('End-of-central-directory signature not found', run.errors)
2761     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2762     self.assertFalse(os.path.exists(tmpdir+"/test"))
2763     self.rm_testdir()
2764   def test_63816(self):
2765     """ unzzip-big $(CVE).zip  """
2766     tmpdir = self.testdir()
2767     filename = self.zip_CVE_2018_12
2768     file_url = self.url_CVE_2018_12
2769     download(file_url, filename, tmpdir)
2770     exe = self.bins("unzzip-big")
2771     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2772         returncodes = [0])
2773     self.assertLess(len(run.output), 30)
2774     self.assertLess(len(errors(run.errors)), 1)
2775     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2776     self.assertFalse(os.path.exists(tmpdir+"/test"))
2777     self.rm_testdir()
2778   def test_63817(self):
2779     """ unzzip-mem $(CVE).zip  """
2780     tmpdir = self.testdir()
2781     filename = self.zip_CVE_2018_12
2782     file_url = self.url_CVE_2018_12
2783     download(file_url, filename, tmpdir)
2784     exe = self.bins("unzzip-mem")
2785     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2786         returncodes = [0])
2787     self.assertLess(len(run.output), 30)
2788     self.assertLess(len(errors(run.errors)), 10)
2789     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2790     self.assertFalse(os.path.exists(tmpdir+"/test"))
2791     self.rm_testdir()
2792   @unittest.expectedFailure
2793   def test_63818(self):
2794     """ unzzip-mix $(CVE).zip  """
2795     tmpdir = self.testdir()
2796     filename = self.zip_CVE_2018_12
2797     file_url = self.url_CVE_2018_12
2798     download(file_url, filename, tmpdir)
2799     exe = self.bins("unzzip-mix")
2800     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2801         returncodes = [0])
2802     self.assertLess(len(run.output), 30)
2803     self.assertLess(len(errors(run.errors)), 10)
2804     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2805     self.assertFalse(os.path.exists(tmpdir+"/test"))
2806     self.rm_testdir()
2807   @unittest.expectedFailure
2808   def test_63819(self):
2809     """ unzzip $(CVE).zip  """
2810     tmpdir = self.testdir()
2811     filename = self.zip_CVE_2018_12
2812     file_url = self.url_CVE_2018_12
2813     download(file_url, filename, tmpdir)
2814     exe = self.bins("unzzip")
2815     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2816         returncodes = [0])
2817     self.assertLess(len(run.output), 30)
2818     self.assertLess(len(errors(run.errors)), 10)
2819     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2820     self.assertFalse(os.path.exists(tmpdir+"/test"))
2821     self.rm_testdir()
2822
2823   url_CVE_2018_14 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
2824   zip_CVE_2018_14 = "zziplib_0-13-67_zzdir_memory-alignment-errors___zzip_fetch_disk_trailer.zip"
2825   def test_64840(self):
2826     """ info unzip -l $(CVE).zip  """
2827     tmpdir = self.testdir()
2828     filename = self.zip_CVE_2018_14
2829     file_url = self.url_CVE_2018_14
2830     download(file_url, filename, tmpdir)
2831     exe = self.bins("unzip")
2832     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2833         returncodes = [0, 9])
2834     self.assertIn("End-of-central-directory signature not found", run.errors)
2835     self.assertLess(len(run.output), 200)
2836     self.assertLess(len(errors(run.errors)), 800)
2837     self.rm_testdir()
2838   def test_64841(self):
2839     """ unzzip-big -l $(CVE).zip  """
2840     tmpdir = self.testdir()
2841     filename = self.zip_CVE_2018_14
2842     file_url = self.url_CVE_2018_14
2843     download(file_url, filename, tmpdir)
2844     exe = self.bins("unzzip-big")
2845     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2846         returncodes = [0])
2847     self.assertLess(len(run.output), 1)
2848     self.assertLess(len(errors(run.errors)), 1)
2849     self.rm_testdir()
2850   def test_64842(self):
2851     """ unzzip-mem -l $(CVE).zip """
2852     tmpdir = self.testdir()
2853     filename = self.zip_CVE_2018_14
2854     file_url = self.url_CVE_2018_14
2855     download(file_url, filename, tmpdir)
2856     exe = self.bins("unzzip-mem")
2857     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2858         returncodes = [0])
2859     self.assertLess(len(run.output), 1)
2860     self.rm_testdir()
2861   def test_64843(self):
2862     """ unzzip-mix -l $(CVE).zip  """
2863     tmpdir = self.testdir()
2864     filename = self.zip_CVE_2018_14
2865     file_url = self.url_CVE_2018_14
2866     download(file_url, filename, tmpdir)
2867     exe = self.bins("unzzip-mix")
2868     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2869         returncodes = [0, 2])
2870     self.assertLess(len(run.output), 1)
2871     self.assertTrue(greps(run.errors, "central directory not found"))
2872     self.rm_testdir()
2873   def test_64844(self):
2874     """ unzzip-zap -l $(CVE).zip  """
2875     tmpdir = self.testdir()
2876     filename = self.zip_CVE_2018_14
2877     file_url = self.url_CVE_2018_14
2878     download(file_url, filename, tmpdir)
2879     exe = self.bins("unzzip")
2880     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2881         returncodes = [0, 3])
2882     self.assertLess(len(run.output), 1)
2883     self.assertLess(len(errors(run.errors)), 200)
2884     self.assertIn(": Success", run.errors)
2885     self.rm_testdir()
2886   def test_64845(self):
2887     """ info unzip $(CVE).zip  """
2888     tmpdir = self.testdir()
2889     filename = self.zip_CVE_2018_14
2890     file_url = self.url_CVE_2018_14
2891     download(file_url, filename, tmpdir)
2892     exe = self.bins("unzip")
2893     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
2894         returncodes = [9])
2895     self.assertLess(len(run.output), 200)
2896     self.assertLess(len(errors(run.errors)), 800)
2897     self.assertIn('End-of-central-directory signature not found', run.errors)
2898     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2899     self.assertFalse(os.path.exists(tmpdir+"/test"))
2900     self.rm_testdir()
2901   def test_64846(self):
2902     """ unzzip-big $(CVE).zip  """
2903     tmpdir = self.testdir()
2904     filename = self.zip_CVE_2018_14
2905     file_url = self.url_CVE_2018_14
2906     download(file_url, filename, tmpdir)
2907     exe = self.bins("unzzip-big")
2908     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2909         returncodes = [0])
2910     self.assertLess(len(run.output), 30)
2911     self.assertLess(len(errors(run.errors)), 1)
2912     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2913     self.assertFalse(os.path.exists(tmpdir+"/test"))
2914     self.rm_testdir()
2915   def test_64847(self):
2916     """ unzzip-mem $(CVE).zip  """
2917     tmpdir = self.testdir()
2918     filename = self.zip_CVE_2018_14
2919     file_url = self.url_CVE_2018_14
2920     download(file_url, filename, tmpdir)
2921     exe = self.bins("unzzip-mem")
2922     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2923         returncodes = [0])
2924     self.assertLess(len(run.output), 30)
2925     self.assertLess(len(errors(run.errors)), 10)
2926     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2927     self.assertFalse(os.path.exists(tmpdir+"/test"))
2928     self.rm_testdir()
2929   def test_64848(self):
2930     """ unzzip-mix $(CVE).zip  """
2931     tmpdir = self.testdir()
2932     filename = self.zip_CVE_2018_14
2933     file_url = self.url_CVE_2018_14
2934     download(file_url, filename, tmpdir)
2935     exe = self.bins("unzzip-mix")
2936     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2937         returncodes = [0,2])
2938     self.assertLess(len(run.output), 30)
2939     self.assertLess(len(errors(run.errors)), 10)
2940     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2941     self.assertFalse(os.path.exists(tmpdir+"/test"))
2942     self.rm_testdir()
2943   def test_64849(self):
2944     """ unzzip $(CVE).zip  """
2945     tmpdir = self.testdir()
2946     filename = self.zip_CVE_2018_14
2947     file_url = self.url_CVE_2018_14
2948     download(file_url, filename, tmpdir)
2949     exe = self.bins("unzzip")
2950     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
2951         returncodes = [0,3])
2952     self.assertLess(len(run.output), 30)
2953     self.assertLess(len(errors(run.errors)), 10)
2954     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
2955     self.assertFalse(os.path.exists(tmpdir+"/test"))
2956     self.rm_testdir()
2957
2958   url_CVE_2018_15 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
2959   zip_CVE_2018_15 = "zziplib_0-13-67_unzip-mem_memory-alignment-errors_zzip_disk_findfirst.zip"
2960   def test_65400(self):
2961     """ info unzip -l $(CVE).zip  """
2962     tmpdir = self.testdir()
2963     filename = self.zip_CVE_2018_15
2964     file_url = self.url_CVE_2018_15
2965     download(file_url, filename, tmpdir)
2966     exe = self.bins("unzip")
2967     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2968         returncodes = [0, 9])
2969     self.assertIn("End-of-central-directory signature not found", run.errors)
2970     self.assertLess(len(run.output), 200)
2971     self.assertLess(len(errors(run.errors)), 800)
2972     self.rm_testdir()
2973   def test_65401(self):
2974     """ unzzip-big -l $(CVE).zip  """
2975     tmpdir = self.testdir()
2976     filename = self.zip_CVE_2018_15
2977     file_url = self.url_CVE_2018_15
2978     download(file_url, filename, tmpdir)
2979     exe = self.bins("unzzip-big")
2980     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2981         returncodes = [0])
2982     self.assertLess(len(run.output), 1)
2983     self.assertLess(len(errors(run.errors)), 1)
2984     self.rm_testdir()
2985   def test_65402(self):
2986     """ unzzip-mem -l $(CVE).zip """
2987     tmpdir = self.testdir()
2988     filename = self.zip_CVE_2018_15
2989     file_url = self.url_CVE_2018_15
2990     download(file_url, filename, tmpdir)
2991     exe = self.bins("unzzip-mem")
2992     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
2993         returncodes = [0])
2994     self.assertLess(len(run.output), 1)
2995     self.assertLess(len(errors(run.errors)), 1)
2996     self.rm_testdir()
2997   def test_65403(self):
2998     """ unzzip-mix -l $(CVE).zip  """
2999     tmpdir = self.testdir()
3000     filename = self.zip_CVE_2018_15
3001     file_url = self.url_CVE_2018_15
3002     download(file_url, filename, tmpdir)
3003     exe = self.bins("unzzip-mix")
3004     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3005         returncodes = [0,2])
3006     self.assertLess(len(run.output), 1)
3007     self.assertTrue(grep(run.errors, "central directory not found"))
3008     self.rm_testdir()
3009   def test_65404(self):
3010     """ unzzip-zap -l $(CVE).zip  """
3011     tmpdir = self.testdir()
3012     filename = self.zip_CVE_2018_15
3013     file_url = self.url_CVE_2018_15
3014     download(file_url, filename, tmpdir)
3015     exe = self.bins("unzzip")
3016     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3017         returncodes = [0, 3])
3018     self.assertLess(len(run.output), 1)
3019     self.assertLess(len(errors(run.errors)), 200)
3020     self.assertIn(": Success", run.errors)
3021     self.rm_testdir()
3022   def test_65405(self):
3023     """ info unzip $(CVE).zip  """
3024     tmpdir = self.testdir()
3025     filename = self.zip_CVE_2018_15
3026     file_url = self.url_CVE_2018_15
3027     download(file_url, filename, tmpdir)
3028     exe = self.bins("unzip")
3029     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
3030         returncodes = [9])
3031     self.assertLess(len(run.output), 200)
3032     self.assertLess(len(errors(run.errors)), 800)
3033     self.assertIn('End-of-central-directory signature not found', run.errors)
3034     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3035     self.assertFalse(os.path.exists(tmpdir+"/test"))
3036     self.rm_testdir()
3037   def test_65406(self):
3038     """ unzzip-big $(CVE).zip  """
3039     tmpdir = self.testdir()
3040     filename = self.zip_CVE_2018_15
3041     file_url = self.url_CVE_2018_15
3042     download(file_url, filename, tmpdir)
3043     exe = self.bins("unzzip-big")
3044     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3045         returncodes = [0])
3046     self.assertLess(len(run.output), 30)
3047     self.assertLess(len(errors(run.errors)), 1)
3048     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3049     self.assertFalse(os.path.exists(tmpdir+"/test"))
3050     self.rm_testdir()
3051   def test_65407(self):
3052     """ unzzip-mem $(CVE).zip  """
3053     tmpdir = self.testdir()
3054     filename = self.zip_CVE_2018_15
3055     file_url = self.url_CVE_2018_15
3056     download(file_url, filename, tmpdir)
3057     exe = self.bins("unzzip-mem")
3058     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3059         returncodes = [0])
3060     self.assertLess(len(run.output), 30)
3061     self.assertLess(len(errors(run.errors)), 10)
3062     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3063     self.assertFalse(os.path.exists(tmpdir+"/test"))
3064     self.rm_testdir()
3065   def test_65408(self):
3066     """ unzzip-mix $(CVE).zip  """
3067     tmpdir = self.testdir()
3068     filename = self.zip_CVE_2018_15
3069     file_url = self.url_CVE_2018_15
3070     download(file_url, filename, tmpdir)
3071     exe = self.bins("unzzip-mix")
3072     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3073         returncodes = [0,2])
3074     self.assertLess(len(run.output), 30)
3075     self.assertLess(len(errors(run.errors)), 10)
3076     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3077     self.assertFalse(os.path.exists(tmpdir+"/test"))
3078     self.rm_testdir()
3079   def test_65409(self):
3080     """ unzzip $(CVE).zip  """
3081     tmpdir = self.testdir()
3082     filename = self.zip_CVE_2018_15
3083     file_url = self.url_CVE_2018_15
3084     download(file_url, filename, tmpdir)
3085     exe = self.bins("unzzip")
3086     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3087         returncodes = [0,3])
3088     self.assertLess(len(run.output), 30)
3089     self.assertLess(len(errors(run.errors)), 10)
3090     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3091     self.assertFalse(os.path.exists(tmpdir+"/test"))
3092     self.rm_testdir()
3093
3094   url_CVE_2018_16 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
3095   zip_CVE_2018_16 = "zziplib_0-13-67_unzzip_memory-aligment-errors___zzip_fetch_disk_trailer.zip"
3096   def test_65410(self):
3097     """ info unzip -l $(CVE).zip  """
3098     tmpdir = self.testdir()
3099     filename = self.zip_CVE_2018_16
3100     file_url = self.url_CVE_2018_16
3101     download(file_url, filename, tmpdir)
3102     exe = self.bins("unzip")
3103     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3104         returncodes = [0, 9])
3105     self.assertIn("End-of-central-directory signature not found", run.errors)
3106     self.assertLess(len(run.output), 200)
3107     self.assertLess(len(errors(run.errors)), 800)
3108     self.rm_testdir()
3109   def test_65411(self):
3110     """ unzzip-big -l $(CVE).zip  """
3111     tmpdir = self.testdir()
3112     filename = self.zip_CVE_2018_16
3113     file_url = self.url_CVE_2018_16
3114     download(file_url, filename, tmpdir)
3115     exe = self.bins("unzzip-big")
3116     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3117         returncodes = [0])
3118     self.assertLess(len(run.output), 1)
3119     self.assertLess(len(errors(run.errors)), 1)
3120     self.rm_testdir()
3121   def test_65412(self):
3122     """ unzzip-mem -l $(CVE).zip """
3123     tmpdir = self.testdir()
3124     filename = self.zip_CVE_2018_16
3125     file_url = self.url_CVE_2018_16
3126     download(file_url, filename, tmpdir)
3127     exe = self.bins("unzzip-mem")
3128     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3129         returncodes = [0])
3130     self.assertLess(len(run.output), 1)
3131     self.assertLess(len(errors(run.errors)), 1)
3132     self.rm_testdir()
3133   def test_65413(self):
3134     """ unzzip-mix -l $(CVE).zip  """
3135     tmpdir = self.testdir()
3136     filename = self.zip_CVE_2018_16
3137     file_url = self.url_CVE_2018_16
3138     download(file_url, filename, tmpdir)
3139     exe = self.bins("unzzip-mix")
3140     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3141         returncodes = [0,2])
3142     self.assertLess(len(run.output), 1)
3143     self.assertTrue(grep(run.errors, "central directory not found"))
3144     self.rm_testdir()
3145   def test_65414(self):
3146     """ unzzip-zap -l $(CVE).zip  """
3147     tmpdir = self.testdir()
3148     filename = self.zip_CVE_2018_16
3149     file_url = self.url_CVE_2018_16
3150     download(file_url, filename, tmpdir)
3151     exe = self.bins("unzzip")
3152     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3153         returncodes = [0, 3])
3154     self.assertLess(len(run.output), 1)
3155     self.assertLess(len(errors(run.errors)), 200)
3156     self.assertIn(": Success", run.errors)
3157     self.rm_testdir()
3158   def test_65415(self):
3159     """ info unzip $(CVE).zip  """
3160     tmpdir = self.testdir()
3161     filename = self.zip_CVE_2018_16
3162     file_url = self.url_CVE_2018_16
3163     download(file_url, filename, tmpdir)
3164     exe = self.bins("unzip")
3165     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
3166         returncodes = [9])
3167     self.assertLess(len(run.output), 200)
3168     self.assertLess(len(errors(run.errors)), 800)
3169     self.assertIn('End-of-central-directory signature not found', run.errors)
3170     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3171     self.assertFalse(os.path.exists(tmpdir+"/test"))
3172     self.rm_testdir()
3173   def test_65416(self):
3174     """ unzzip-big $(CVE).zip  """
3175     tmpdir = self.testdir()
3176     filename = self.zip_CVE_2018_16
3177     file_url = self.url_CVE_2018_16
3178     download(file_url, filename, tmpdir)
3179     exe = self.bins("unzzip-big")
3180     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3181         returncodes = [0])
3182     self.assertLess(len(run.output), 30)
3183     self.assertLess(len(errors(run.errors)), 1)
3184     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3185     self.assertFalse(os.path.exists(tmpdir+"/test"))
3186     self.rm_testdir()
3187   def test_65417(self):
3188     """ unzzip-mem $(CVE).zip  """
3189     tmpdir = self.testdir()
3190     filename = self.zip_CVE_2018_16
3191     file_url = self.url_CVE_2018_16
3192     download(file_url, filename, tmpdir)
3193     exe = self.bins("unzzip-mem")
3194     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3195         returncodes = [0])
3196     self.assertLess(len(run.output), 30)
3197     self.assertLess(len(errors(run.errors)), 10)
3198     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3199     self.assertFalse(os.path.exists(tmpdir+"/test"))
3200     self.rm_testdir()
3201   def test_65418(self):
3202     """ unzzip-mix $(CVE).zip  """
3203     tmpdir = self.testdir()
3204     filename = self.zip_CVE_2018_16
3205     file_url = self.url_CVE_2018_16
3206     download(file_url, filename, tmpdir)
3207     exe = self.bins("unzzip-mix")
3208     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3209         returncodes = [0,2])
3210     self.assertLess(len(run.output), 30)
3211     self.assertLess(len(errors(run.errors)), 10)
3212     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3213     self.assertFalse(os.path.exists(tmpdir+"/test"))
3214     self.rm_testdir()
3215   def test_65419(self):
3216     """ unzzip $(CVE).zip  """
3217     tmpdir = self.testdir()
3218     filename = self.zip_CVE_2018_16
3219     file_url = self.url_CVE_2018_16
3220     download(file_url, filename, tmpdir)
3221     exe = self.bins("unzzip")
3222     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3223         returncodes = [0,3])
3224     self.assertLess(len(run.output), 30)
3225     self.assertLess(len(errors(run.errors)), 10)
3226     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3227     self.assertFalse(os.path.exists(tmpdir+"/test"))
3228     self.rm_testdir()
3229
3230   url_CVE_2018_17 = "https://github.com/ProbeFuzzer/poc/blob/master/zziplib"
3231   zip_CVE_2018_17 = "zziplib_0-13-67_unzip-mem_memory-alignment-errors_zzip_disk_findfirst_64.zip"
3232   def test_65420(self):
3233     """ info unzip -l $(CVE).zip  """
3234     tmpdir = self.testdir()
3235     filename = self.zip_CVE_2018_17
3236     file_url = self.url_CVE_2018_17
3237     download(file_url, filename, tmpdir)
3238     exe = self.bins("unzip")
3239     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3240         returncodes = [0, 9])
3241     self.assertIn("End-of-central-directory signature not found", run.errors)
3242     self.assertLess(len(run.output), 200)
3243     self.assertLess(len(errors(run.errors)), 800)
3244     self.rm_testdir()
3245   def test_65421(self):
3246     """ unzzip-big -l $(CVE).zip  """
3247     tmpdir = self.testdir()
3248     filename = self.zip_CVE_2018_17
3249     file_url = self.url_CVE_2018_17
3250     download(file_url, filename, tmpdir)
3251     exe = self.bins("unzzip-big")
3252     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3253         returncodes = [0])
3254     self.assertLess(len(run.output), 1)
3255     self.assertTrue(grep(run.errors, "central directory not found"))
3256     self.rm_testdir()
3257   def test_65422(self):
3258     """ unzzip-mem -l $(CVE).zip """
3259     tmpdir = self.testdir()
3260     filename = self.zip_CVE_2018_17
3261     file_url = self.url_CVE_2018_17
3262     download(file_url, filename, tmpdir)
3263     exe = self.bins("unzzip-mem")
3264     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3265         returncodes = [0])
3266     self.assertLess(len(run.output), 1)
3267     self.assertLess(len(errors(run.errors)), 1)
3268     self.rm_testdir()
3269   def test_65423(self):
3270     """ unzzip-mix -l $(CVE).zip  """
3271     tmpdir = self.testdir()
3272     filename = self.zip_CVE_2018_17
3273     file_url = self.url_CVE_2018_17
3274     download(file_url, filename, tmpdir)
3275     exe = self.bins("unzzip-mix")
3276     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3277         returncodes = [0,2])
3278     self.assertLess(len(run.output), 1)
3279     self.assertTrue(grep(run.errors, "central directory not found"))
3280     self.rm_testdir()
3281   def test_65424(self):
3282     """ unzzip-zap -l $(CVE).zip  """
3283     tmpdir = self.testdir()
3284     filename = self.zip_CVE_2018_17
3285     file_url = self.url_CVE_2018_17
3286     download(file_url, filename, tmpdir)
3287     exe = self.bins("unzzip")
3288     run = shell("{exe} -l {tmpdir}/{filename} ".format(**locals()),
3289         returncodes = [0, 3])
3290     self.assertLess(len(run.output), 1)
3291     self.assertLess(len(errors(run.errors)), 200)
3292     self.assertIn(": Success", run.errors)
3293     self.rm_testdir()
3294   def test_65425(self):
3295     """ info unzip $(CVE).zip  """
3296     tmpdir = self.testdir()
3297     filename = self.zip_CVE_2018_17
3298     file_url = self.url_CVE_2018_17
3299     download(file_url, filename, tmpdir)
3300     exe = self.bins("unzip")
3301     run = shell("cd {tmpdir} && {exe} -o {filename}".format(**locals()),
3302         returncodes = [9])
3303     self.assertLess(len(run.output), 200)
3304     self.assertLess(len(errors(run.errors)), 800)
3305     self.assertIn('End-of-central-directory signature not found', run.errors)
3306     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3307     self.assertFalse(os.path.exists(tmpdir+"/test"))
3308     self.rm_testdir()
3309   def test_65426(self):
3310     """ unzzip-big $(CVE).zip  """
3311     tmpdir = self.testdir()
3312     filename = self.zip_CVE_2018_17
3313     file_url = self.url_CVE_2018_17
3314     download(file_url, filename, tmpdir)
3315     exe = self.bins("unzzip-big")
3316     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3317         returncodes = [0])
3318     self.assertLess(len(run.output), 30)
3319     self.assertLess(len(errors(run.errors)), 1)
3320     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3321     self.assertFalse(os.path.exists(tmpdir+"/test"))
3322     self.rm_testdir()
3323   def test_65427(self):
3324     """ unzzip-mem $(CVE).zip  """
3325     tmpdir = self.testdir()
3326     filename = self.zip_CVE_2018_17
3327     file_url = self.url_CVE_2018_17
3328     download(file_url, filename, tmpdir)
3329     exe = self.bins("unzzip-mem")
3330     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3331         returncodes = [0])
3332     self.assertLess(len(run.output), 30)
3333     self.assertLess(len(errors(run.errors)), 10)
3334     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3335     self.assertFalse(os.path.exists(tmpdir+"/test"))
3336     self.rm_testdir()
3337   def test_65428(self):
3338     """ unzzip-mix $(CVE).zip  """
3339     tmpdir = self.testdir()
3340     filename = self.zip_CVE_2018_17
3341     file_url = self.url_CVE_2018_17
3342     download(file_url, filename, tmpdir)
3343     exe = self.bins("unzzip-mix")
3344     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3345         returncodes = [0,2])
3346     self.assertLess(len(run.output), 30)
3347     self.assertTrue(grep(run.errors, "No medium found"))
3348     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3349     self.assertFalse(os.path.exists(tmpdir+"/test"))
3350     self.rm_testdir()
3351   def test_65429(self):
3352     """ unzzip $(CVE).zip  """
3353     tmpdir = self.testdir()
3354     filename = self.zip_CVE_2018_17
3355     file_url = self.url_CVE_2018_17
3356     download(file_url, filename, tmpdir)
3357     exe = self.bins("unzzip")
3358     run = shell("cd {tmpdir} && ../{exe} {filename} ".format(**locals()),
3359         returncodes = [0,3])
3360     self.assertLess(len(run.output), 30)
3361     self.assertTrue(grep(run.errors, "central directory not found"))
3362     # self.assertEqual(os.path.getsize(tmpdir+"/test"), 3)
3363     self.assertFalse(os.path.exists(tmpdir+"/test"))
3364     self.rm_testdir()
3365
3366
3367   def test_91000_zzshowme_check_sfx(self):
3368     """ create an *.exe that can extract its own zip content """
3369     exe=self.bins("mkzip")
3370     exefile = "tmp.zzshowme" + exeext
3371     libstub = ".libs/zzipself" + exeext
3372     txtfile_name = readme
3373     txtfile = self.src(readme)
3374     # add the extract-stub so we have reserved the size
3375     run = shell("{exe} -0 -j {exefile}.zip {libstub}".format(**locals()))
3376     self.assertFalse(run.returncode)
3377     # add the actual content which may now be compressed
3378     run = shell("{exe} -9 -j {exefile}.zip {txtfile}".format(**locals()))
3379     self.assertFalse(run.returncode)
3380     # rename .zip to .exe and put the extract-stub at the start
3381     shutil.copy(exefile+".zip", exefile)
3382     setstub="./zzipsetstub" + exeext
3383     run = shell("{setstub} {exefile} {libstub}".format(**locals()))
3384     self.assertFalse(run.returncode)
3385     os.chmod(exefile, 0755)
3386     # now ask the new .exe to show some of its own content
3387     run = shell("./{exefile} {txtfile_name}".format(**locals()))
3388     self.assertFalse(run.returncode)
3389     txt = open(txtfile).read()
3390     self.assertEqual(txt.split("\n"), run.output.split("\n"))
3391
3392   def test_99000_make_test1w_zip(self):
3393     """ create a test1w.zip using zzip/write functions. """
3394     exe=self.bins("zzip")
3395     run = shell("{exe} --version".format(**locals()))
3396     if "- NO -" in run.output:
3397         self.skipTest("- NO -D_ZZIP_ENABLE_WRITE")
3398         return
3399     zipfile=self.testzip()
3400     tmpdir=self.testdir()
3401     exe=self.bins("zzip")
3402     for i in [1,2,3,4,5,6,7,8,9]:
3403        filename = os.path.join(tmpdir,"file.%i" % i)
3404        filetext = "file-%i\n" % i
3405        self.mkfile(filename, filetext)
3406     filename = os.path.join(tmpdir,"README")
3407     filetext = self.readme()
3408     self.mkfile(filename, filetext)
3409     self.rm_zipfile()
3410     shell("../{exe} ../{zipfile} ??*.* README".format(**locals()), cwd=tmpdir)
3411     self.assertGreater(os.path.getsize(zipfile), 10)
3412
3413
3414
3415
3416 if __name__ == "__main__":
3417   import optparse
3418   _o = optparse.OptionParser("%prog [options] test_xxx")
3419   _o.add_option("-b", "--topsrcdir", metavar="DIR", default=topsrcdir,
3420     help="path to the top srcdir / unpack directory [%default]")
3421   _o.add_option("-t", "--testdatadir", metavar="DIR", default=testdatadir,
3422     help="path where temporary testdata is created [%default]")
3423   _o.add_option("-Z", "--mkzip", metavar="EXE", default=mkzip,
3424     help="name or path to zip.exe for *.zip creation [%default]")
3425   _o.add_option("-U", "--unzip", metavar="EXE", default=unzip,
3426     help="name or path to unzip.exe to unpack *.zip [%default]")
3427   _o.add_option("-E", "--exeext", metavar="EXT", default=exeext,
3428     help="the executable extension (automake $(EXEEXT)) [%default]")
3429   _o.add_option("--xmlresults", action="store_true", default=False,
3430     help="print output in junit xml testresult format [%default]")
3431   _o.add_option("-v", "--verbose", action="count", default=0,
3432     help="increase logging output [%default]")
3433   opt, args = _o.parse_args()
3434   logging.basicConfig(level = logging.WARNING - 10 * opt.verbose)
3435   topsrcdir = opt.topsrcdir
3436   testdatdir = opt.testdatadir
3437   mkzip = opt.mkzip
3438   unzip = opt.unzip
3439   exeext = opt.exeext
3440   if not args: args += [ "test_" ]
3441   suite = unittest.TestSuite()
3442   for arg in args:
3443     for classname in sorted(list(globals())):
3444       if not classname.endswith("Test"):
3445         continue
3446       testclass = globals()[classname]
3447       for method in sorted(dir(testclass)):
3448         if "*" not in arg: arg += "*"
3449         if arg.startswith("_"): arg = arg[1:]
3450         if matches(method, arg):
3451           suite.addTest(testclass(method))
3452   # TextTestRunner(verbosity=opt.verbose).run(suite)
3453   if opt.xmlresults:
3454     import xmlrunner
3455     Runner = xmlrunner.XMLTestRunner
3456     Runner(xmlresults).run(suite)
3457   else:
3458     Runner = unittest.TextTestRunner
3459     Runner(verbosity=opt.verbose).run(suite)
3460