1#!/usr/local/bin/python3.8
2""" Testcases for zziplib build system """
3
4__copyright__ = "(C) Guido Draheim, all rights reserved"""
5__version__ = "0.13.72"
6
7import subprocess
8import os.path
9import time
10import datetime
11import unittest
12import shutil
13import inspect
14import types
15import logging
16import re
17from fnmatch import fnmatchcase as fnmatch
18from glob import glob
19import json
20import sys
21
22if sys.version[0] == '3':
23    basestring = str
24    xrange = range
25
26logg = logging.getLogger("TESTING")
27_python = "/usr/bin/python"
28
29SAVETO = "localhost:5000/zziplib"
30IMAGES = "localhost:5000/zziplib/image"
31CENTOS8 = "centos:8.3.2011"
32CENTOS7 = "centos:7.9.2009"
33UBUNTU1 = "ubuntu:18.04"
34UBUNTU2 = "ubuntu:16.04"
35UBUNTU3 = "ubuntu:20.04"
36OPENSUSE5 = "opensuse/leap:15.2"
37SOFTWARE = "../Software"
38
39DOCKER_SOCKET = "/var/run/docker.sock"
40DOCKER = "docker"
41FORCE = False
42NOCACHE = False
43
44MAINDIR = os.path.dirname(sys.argv[0]) or "."
45MIRROR = os.path.join(MAINDIR, "docker_mirror.py")
46
47def decodes(text):
48    if text is None: return None
49    if isinstance(text, bytes):
50        encoded = sys.getdefaultencoding()
51        if encoded in ["ascii"]:
52            encoded = "utf-8"
53        try:
54            return text.decode(encoded)
55        except:
56            return text.decode("latin-1")
57    return text
58def sh____(cmd, shell=True):
59    if isinstance(cmd, basestring):
60        logg.info(": %s", cmd)
61    else:
62        logg.info(": %s", " ".join(["'%s'" % item for item in cmd]))
63    return subprocess.check_call(cmd, shell=shell)
64def sx____(cmd, shell=True):
65    if isinstance(cmd, basestring):
66        logg.info(": %s", cmd)
67    else:
68        logg.info(": %s", " ".join(["'%s'" % item for item in cmd]))
69    return subprocess.call(cmd, shell=shell)
70def output(cmd, shell=True):
71    if isinstance(cmd, basestring):
72        logg.info(": %s", cmd)
73    else:
74        logg.info(": %s", " ".join(["'%s'" % item for item in cmd]))
75    run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
76    out, err = run.communicate()
77    return decodes(out)
78def output2(cmd, shell=True):
79    if isinstance(cmd, basestring):
80        logg.info(": %s", cmd)
81    else:
82        logg.info(": %s", " ".join(["'%s'" % item for item in cmd]))
83    run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
84    out, err = run.communicate()
85    return decodes(out), run.returncode
86def output3(cmd, shell=True):
87    if isinstance(cmd, basestring):
88        logg.info(": %s", cmd)
89    else:
90        logg.info(": %s", " ".join(["'%s'" % item for item in cmd]))
91    run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
92    out, err = run.communicate()
93    return decodes(out), decodes(err), run.returncode
94def background(cmd, shell=True):
95    BackgroundProcess = collections.namedtuple("BackgroundProcess", ["pid", "run", "log" ])
96    log = open(os.devnull, "wb")
97    run = subprocess.Popen(cmd, shell=shell, stdout=log, stderr=log)
98    pid = run.pid
99    logg.info("PID %s = %s", pid, cmd)
100    return BackgroundProcess(pid, run, log)
101
102
103
104def _lines(lines):
105    if isinstance(lines, basestring):
106        lines = lines.split("\n")
107        if len(lines) and lines[-1] == "":
108            lines = lines[:-1]
109    return lines
110def lines(text):
111    lines = []
112    for line in _lines(text):
113        lines.append(line.rstrip())
114    return lines
115def grep(pattern, lines):
116    for line in _lines(lines):
117       if re.search(pattern, line.rstrip()):
118           yield line.rstrip()
119def greps(lines, pattern):
120    return list(grep(pattern, lines))
121
122def download(base_url, filename, into):
123    if not os.path.isdir(into):
124        os.makedirs(into)
125    if not os.path.exists(os.path.join(into, filename)):
126        sh____("cd {into} && wget {base_url}/{filename}".format(**locals()))
127def text_file(filename, content):
128    filedir = os.path.dirname(filename)
129    if not os.path.isdir(filedir):
130        os.makedirs(filedir)
131    f = open(filename, "w")
132    if content.startswith("\n"):
133        x = re.match("(?s)\n( *)", content)
134        indent = x.group(1)
135        for line in content[1:].split("\n"):
136            if line.startswith(indent):
137                line = line[len(indent):]
138            f.write(line+"\n")
139    else:
140        f.write(content)
141    f.close()
142def shell_file(filename, content):
143    text_file(filename, content)
144    os.chmod(filename, 0o770)
145def copy_file(filename, target):
146    targetdir = os.path.dirname(target)
147    if not os.path.isdir(targetdir):
148        os.makedirs(targetdir)
149    shutil.copyfile(filename, target)
150def copy_tool(filename, target):
151    copy_file(filename, target)
152    os.chmod(target, 0o750)
153
154def get_caller_name():
155    frame = inspect.currentframe().f_back.f_back
156    return frame.f_code.co_name
157def get_caller_caller_name():
158    frame = inspect.currentframe().f_back.f_back.f_back
159    return frame.f_code.co_name
160def os_path(root, path):
161    if not root:
162        return path
163    if not path:
164        return path
165    while path.startswith(os.path.sep):
166       path = path[1:]
167    return os.path.join(root, path)
168def docname(path):
169    return os.path.splitext(os.path.basename(path))[0]
170
171def link_software(software, parts):
172    software = software or "Software"
173    shelf = SOFTWARE
174    for part in parts.split(","):
175        item = os.path.join(shelf, part)
176        if os.path.isdir(item):
177            for dirpath, dirnames, filenames in os.walk(item):
178                basepath = dirpath.replace(shelf+"/", "")
179                for filename in filenames:
180                    intofile = os.path.join(software, basepath, filename)
181                    fromfile = os.path.join(dirpath, filename)
182                    intodir = os.path.dirname(intofile)
183                    if not os.path.isdir(intodir):
184                        os.makedirs(intodir)
185                    if not os.path.isfile(intofile):
186                        os.link(fromfile, intofile)
187def unlink_software(software, parts):
188    software = software or "Software"
189    shelf = SOFTWARE
190    for part in parts.split(","):
191        item = os.path.join(shelf, part)
192        if os.path.isdir(item):
193            for dirpath, dirnames, filenames in os.walk(item):
194                basepath = dirpath.replace(shelf+"/", "")
195                for filename in filenames:
196                    intofile = os.path.join(software, basepath, filename)
197                    if os.path.isfile(intofile):
198                        os.unlink(intofile)
199
200class ZZiplibBuildTest(unittest.TestCase):
201    def caller_testname(self):
202        name = get_caller_caller_name()
203        x1 = name.find("_")
204        if x1 < 0: return name
205        x2 = name.find("_", x1+1)
206        if x2 < 0: return name
207        return name[:x2]
208    def testname(self, suffix = None):
209        name = self.caller_testname()
210        if suffix:
211            return name + "_" + suffix
212        return name
213    def testdir(self, testname = None):
214        testname = testname or self.caller_testname()
215        newdir = "tmp/tmp."+testname
216        if os.path.isdir(newdir):
217            shutil.rmtree(newdir)
218        os.makedirs(newdir)
219        return newdir
220    def rm_old(self, testname = None):
221        testname = testname or self.caller_testname()
222        for subdir in ("docs/man3", "docs/html"):
223            if os.path.isdir(subdir):
224                logg.info("rm -rf %s", subdir)
225                shutil.rmtree(subdir)
226        for filename in ("tmp.local.tgz", "docs/htmpages.tar", "docs/manpages.tar", "docs/zziplib.xml", "docs/zzipmmapped.xml", "docs/zzipfseeko.xml"):
227            if os.path.isfile(filename):
228                logg.info("rm %s", filename)
229                os.remove(filename)
230    def rm_testdir(self, testname = None):
231        testname = testname or self.caller_testname()
232        newdir = "tmp/tmp."+testname
233        if os.path.isdir(newdir):
234            shutil.rmtree(newdir)
235        return newdir
236    def makedirs(self, path):
237        if not os.path.isdir(path):
238            os.makedirs(path)
239    def user(self):
240        import getpass
241        getpass.getuser()
242    def ip_container(self, name):
243        values = output("docker inspect "+name)
244        values = json.loads(values)
245        if not values or "NetworkSettings" not in values[0]:
246            logg.critical(" docker inspect %s => %s ", name, values)
247        return values[0]["NetworkSettings"]["IPAddress"]
248    def local_image(self, image):
249        """ attach local centos-repo / opensuse-repo to docker-start enviroment.
250            Effectivly when it is required to 'docker start centos:x.y' then do
251            'docker start centos-repo:x.y' before and extend the original to
252            'docker start --add-host mirror...:centos-repo centos:x.y'. """
253        if os.environ.get("NONLOCAL",""):
254            return image
255        add_hosts = self.start_mirror(image)
256        if add_hosts:
257            return "{add_hosts} {image}".format(**locals())
258        return image
259    def local_addhosts(self, dockerfile, extras = None):
260        image = ""
261        for line in open(dockerfile):
262            m = re.match('[Ff][Rr][Oo][Mm] *"([^"]*)"', line)
263            if m:
264                image = m.group(1)
265                break
266            m = re.match("[Ff][Rr][Oo][Mm] *(\w[^ ]*)", line)
267            if m:
268                image = m.group(1).strip()
269                break
270        logg.debug("--\n-- '%s' FROM '%s'", dockerfile, image)
271        if image:
272            return self.start_mirror(image, extras)
273        return ""
274    def start_mirror(self, image, extras = None):
275        extras = extras or ""
276        docker = DOCKER
277        mirror = MIRROR
278        cmd = "{mirror} start {image} --add-hosts {extras}"
279        out = output(cmd.format(**locals()))
280        return decodes(out).strip()
281    def nocache(self):
282        if FORCE or NOCACHE:
283            return " --no-cache"
284        return ""
285    #
286    # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
287    #
288    def test_101(self):
289        logg.info("\n  UBUNTU1 = '%s'", UBUNTU1)
290        self.start_mirror(UBUNTU1)
291    def test_102(self):
292        logg.info("\n  UBUNTU2 = '%s'", UBUNTU2)
293        self.start_mirror(UBUNTU2)
294    def test_103(self):
295        logg.info("\n  UBUNTU3 = '%s'", UBUNTU3)
296        self.start_mirror(UBUNTU3, "--universe")
297    def test_105(self):
298        logg.info("\n  OPENSUSE5 = '%s'", OPENSUSE5)
299        self.start_mirror(OPENSUSE5)
300    def test_107(self):
301        logg.info("\n  CENTOS7 = '%s'", CENTOS7)
302        self.start_mirror(CENTOS7, "--epel")
303    def test_108(self):
304        logg.info("\n  CENTOS8 = '%s'", CENTOS8)
305        self.start_mirror(CENTOS8)
306    def test_207_centos7_automake_dockerfile(self):
307        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
308        self.rm_old()
309        self.rm_testdir()
310        testname=self.testname()
311        testdir = self.testdir()
312        dockerfile="testbuilds/centos7-am-build.dockerfile"
313        addhosts = self.local_addhosts(dockerfile, "--epel")
314        savename = docname(dockerfile)
315        saveto = SAVETO
316        images = IMAGES
317        build = "build --build-arg=no_check=true" + self.nocache()
318        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
319        sh____(cmd.format(**locals()))
320        cmd = "docker rm --force {testname}"
321        sx____(cmd.format(**locals()))
322        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
323        sh____(cmd.format(**locals()))
324        #:# container = self.ip_container(testname)
325        cmd = "docker exec {testname} ls -l /usr/local/bin"
326        sh____(cmd.format(**locals()))
327        cmd = "docker exec {testname} find /usr/local/include -type f"
328        sh____(cmd.format(**locals()))
329        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
330        sh____(cmd.format(**locals()))
331        #
332        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
333        sh____(cmd.format(**locals()))
334        cmd = "docker exec {testname} rpm -q --whatprovides /usr/lib64/pkgconfig/zlib.pc"
335        sh____(cmd.format(**locals()))
336        cmd = "docker exec {testname} pkg-config --libs zlib"
337        zlib = output(cmd.format(**locals()))
338        self.assertEqual(zlib.strip(), "-lz")
339        #
340        cmd = "docker rm --force {testname}"
341        sx____(cmd.format(**locals()))
342        cmd = "docker rmi {saveto}/{savename}:latest"
343        sx____(cmd.format(**locals()))
344        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
345        sh____(cmd.format(**locals()))
346        cmd = "docker rmi {images}:{testname}"
347        sx____(cmd.format(**locals()))
348        self.rm_testdir()
349    def test_208_centos8_automake_dockerfile(self):
350        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
351        self.rm_old()
352        self.rm_testdir()
353        testname=self.testname()
354        testdir = self.testdir()
355        dockerfile="testbuilds/centos8-am-build.dockerfile"
356        addhosts = self.local_addhosts(dockerfile)
357        savename = docname(dockerfile)
358        saveto = SAVETO
359        images = IMAGES
360        build = "build --build-arg=no_check=true" + self.nocache()
361        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
362        sh____(cmd.format(**locals()))
363        cmd = "docker rm --force {testname}"
364        sx____(cmd.format(**locals()))
365        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
366        sh____(cmd.format(**locals()))
367        #:# container = self.ip_container(testname)
368        cmd = "docker exec {testname} ls -l /usr/local/bin"
369        sh____(cmd.format(**locals()))
370        cmd = "docker exec {testname} find /usr/local/include -type f"
371        sh____(cmd.format(**locals()))
372        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
373        sh____(cmd.format(**locals()))
374        #
375        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
376        sh____(cmd.format(**locals()))
377        cmd = "docker exec {testname} rpm -q --whatprovides /usr/lib64/pkgconfig/zlib.pc"
378        sh____(cmd.format(**locals()))
379        cmd = "docker exec {testname} pkg-config --libs zlib"
380        zlib = output(cmd.format(**locals()))
381        self.assertEqual(zlib.strip(), "-lz")
382        #
383        cmd = "docker rm --force {testname}"
384        sx____(cmd.format(**locals()))
385        cmd = "docker rmi {saveto}/{savename}:latest"
386        sx____(cmd.format(**locals()))
387        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
388        sh____(cmd.format(**locals()))
389        cmd = "docker rmi {images}:{testname}"
390        sx____(cmd.format(**locals()))
391        self.rm_testdir()
392    def test_217_centos7_cmake_build_dockerfile(self):
393        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
394        self.rm_old()
395        self.rm_testdir()
396        testname=self.testname()
397        testdir = self.testdir()
398        dockerfile="testbuilds/centos7-cm-build.dockerfile"
399        addhosts = self.local_addhosts(dockerfile)
400        savename = docname(dockerfile)
401        saveto = SAVETO
402        images = IMAGES
403        build = "build --build-arg=no_check=true" + self.nocache()
404        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
405        sh____(cmd.format(**locals()))
406        cmd = "docker rm --force {testname}"
407        sx____(cmd.format(**locals()))
408        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
409        sh____(cmd.format(**locals()))
410        #:# container = self.ip_container(testname)
411        cmd = "docker exec {testname} ls -l /usr/local/bin"
412        sh____(cmd.format(**locals()))
413        cmd = "docker exec {testname} find /usr/local/include -type f"
414        sh____(cmd.format(**locals()))
415        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
416        sh____(cmd.format(**locals()))
417        #
418        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
419        sh____(cmd.format(**locals()))
420        cmd = "docker exec {testname} rpm -q --whatprovides /usr/lib64/pkgconfig/zlib.pc"
421        sh____(cmd.format(**locals()))
422        cmd = "docker exec {testname} pkg-config --libs zlib"
423        zlib = output(cmd.format(**locals()))
424        self.assertEqual(zlib.strip(), "-lz")
425        #
426        cmd = "docker rm --force {testname}"
427        sx____(cmd.format(**locals()))
428        cmd = "docker rmi {saveto}/{savename}:latest"
429        sx____(cmd.format(**locals()))
430        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
431        sh____(cmd.format(**locals()))
432        cmd = "docker rmi {images}:{testname}"
433        sx____(cmd.format(**locals()))
434        self.rm_testdir()
435    def test_218_centos8_cmake_build_dockerfile(self):
436        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
437        self.rm_old()
438        self.rm_testdir()
439        testname=self.testname()
440        testdir = self.testdir()
441        dockerfile="testbuilds/centos8-cm-build.dockerfile"
442        addhosts = self.local_addhosts(dockerfile)
443        savename = docname(dockerfile)
444        saveto = SAVETO
445        images = IMAGES
446        build = "build --build-arg=no_check=true" + self.nocache()
447        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
448        sh____(cmd.format(**locals()))
449        cmd = "docker rm --force {testname}"
450        sx____(cmd.format(**locals()))
451        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
452        sh____(cmd.format(**locals()))
453        #:# container = self.ip_container(testname)
454        cmd = "docker exec {testname} ls -l /usr/local/bin"
455        sh____(cmd.format(**locals()))
456        cmd = "docker exec {testname} find /usr/local/include -type f"
457        sh____(cmd.format(**locals()))
458        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
459        sh____(cmd.format(**locals()))
460        #
461        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
462        sh____(cmd.format(**locals()))
463        cmd = "docker exec {testname} rpm -q --whatprovides /usr/lib64/pkgconfig/zlib.pc"
464        sh____(cmd.format(**locals()))
465        cmd = "docker exec {testname} pkg-config --libs zlib"
466        zlib = output(cmd.format(**locals()))
467        self.assertEqual(zlib.strip(), "-lz")
468        #
469        cmd = "docker rm --force {testname}"
470        sx____(cmd.format(**locals()))
471        cmd = "docker rmi {saveto}/{savename}:latest"
472        sx____(cmd.format(**locals()))
473        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
474        sh____(cmd.format(**locals()))
475        cmd = "docker rmi {images}:{testname}"
476        sx____(cmd.format(**locals()))
477        self.rm_testdir()
478    def test_221_ubuntu16_cmake_build_dockerfile(self):
479        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
480        self.rm_old()
481        self.rm_testdir()
482        testname=self.testname()
483        testdir = self.testdir()
484        dockerfile="testbuilds/ubuntu16-cm-build.dockerfile"
485        addhosts = self.local_addhosts(dockerfile)
486        savename = docname(dockerfile)
487        saveto = SAVETO
488        images = IMAGES
489        build = "build --build-arg=no_check=true" + self.nocache()
490        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
491        sh____(cmd.format(**locals()))
492        cmd = "docker rm --force {testname}"
493        sx____(cmd.format(**locals()))
494        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
495        sh____(cmd.format(**locals()))
496        #:# container = self.ip_container(testname)
497        cmd = "docker exec {testname} ls -l /usr/local/bin"
498        sh____(cmd.format(**locals()))
499        cmd = "docker exec {testname} find /usr/local/include -type f"
500        sh____(cmd.format(**locals()))
501        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib/libzz*'"
502        sh____(cmd.format(**locals()))
503        #
504        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
505        sh____(cmd.format(**locals()))
506        cmd = "docker exec {testname} dpkg -S /usr/lib/x86_64-linux-gnu/pkgconfig/zlib.pc"
507        sh____(cmd.format(**locals()))
508        cmd = "docker exec {testname} pkg-config --libs zlib"
509        zlib = output(cmd.format(**locals()))
510        self.assertEqual(zlib.strip(), "-lz")
511        #
512        cmd = "docker rm --force {testname}"
513        sx____(cmd.format(**locals()))
514        cmd = "docker rmi {saveto}/{savename}:latest"
515        sx____(cmd.format(**locals()))
516        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
517        sh____(cmd.format(**locals()))
518        cmd = "docker rmi {images}:{testname}"
519        sx____(cmd.format(**locals()))
520        self.rm_testdir()
521    def test_222_ubuntu18_cmake_build_dockerfile(self):
522        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
523        self.rm_old()
524        self.rm_testdir()
525        testname=self.testname()
526        testdir = self.testdir()
527        dockerfile="testbuilds/ubuntu18-cm-build.dockerfile"
528        addhosts = self.local_addhosts(dockerfile)
529        savename = docname(dockerfile)
530        saveto = SAVETO
531        images = IMAGES
532        build = "build --build-arg=no_check=true" + self.nocache()
533        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
534        sh____(cmd.format(**locals()))
535        cmd = "docker rm --force {testname}"
536        sx____(cmd.format(**locals()))
537        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
538        sh____(cmd.format(**locals()))
539        #:# container = self.ip_container(testname)
540        cmd = "docker exec {testname} ls -l /usr/local/bin"
541        sh____(cmd.format(**locals()))
542        cmd = "docker exec {testname} find /usr/local/include -type f"
543        sh____(cmd.format(**locals()))
544        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib/libzz*'"
545        sh____(cmd.format(**locals()))
546        #
547        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
548        sh____(cmd.format(**locals()))
549        cmd = "docker exec {testname} dpkg -S /usr/lib/x86_64-linux-gnu/pkgconfig/zlib.pc"
550        sh____(cmd.format(**locals()))
551        cmd = "docker exec {testname} pkg-config --libs zlib"
552        zlib = output(cmd.format(**locals()))
553        self.assertEqual(zlib.strip(), "-lz")
554        #
555        cmd = "docker rm --force {testname}"
556        sx____(cmd.format(**locals()))
557        cmd = "docker rmi {saveto}/{savename}:latest"
558        sx____(cmd.format(**locals()))
559        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
560        sh____(cmd.format(**locals()))
561        cmd = "docker rmi {images}:{testname}"
562        sx____(cmd.format(**locals()))
563        self.rm_testdir()
564    def test_224_ubuntu16_32bit_dockerfile(self):
565        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
566        self.rm_old()
567        self.rm_testdir()
568        testname=self.testname()
569        testdir = self.testdir()
570        dockerfile="testbuilds/ubuntu16-32bit.dockerfile"
571        addhosts = self.local_addhosts(dockerfile)
572        savename = docname(dockerfile)
573        saveto = SAVETO
574        images = IMAGES
575        build = "build --build-arg=no_check=true" + self.nocache()
576        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
577        sh____(cmd.format(**locals()))
578        cmd = "docker rm --force {testname}"
579        sx____(cmd.format(**locals()))
580        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
581        sh____(cmd.format(**locals()))
582        #:# container = self.ip_container(testname)
583        cmd = "docker exec {testname} ls -l /usr/local/bin"
584        sh____(cmd.format(**locals()))
585        cmd = "docker exec {testname} find /usr/local/include -type f"
586        sh____(cmd.format(**locals()))
587        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib/libzz*'"
588        sh____(cmd.format(**locals()))
589        #
590        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
591        sh____(cmd.format(**locals()))
592        cmd = "docker exec {testname} dpkg -S /usr/lib/i386-linux-gnu/pkgconfig/zlib.pc"
593        sh____(cmd.format(**locals()))
594        cmd = "docker exec {testname} pkg-config --libs zlib"
595        zlib = output(cmd.format(**locals()))
596        self.assertEqual(zlib.strip(), "-lz")
597        #
598        cmd = "docker rm --force {testname}"
599        sx____(cmd.format(**locals()))
600        cmd = "docker rmi {saveto}/{savename}:latest"
601        sx____(cmd.format(**locals()))
602        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
603        sh____(cmd.format(**locals()))
604        cmd = "docker rmi {images}:{testname}"
605        sx____(cmd.format(**locals()))
606        self.rm_testdir()
607    def test_235_opensuse15_cmake_build_dockerfile(self):
608        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
609        self.rm_old()
610        self.rm_testdir()
611        testname=self.testname()
612        testdir = self.testdir()
613        dockerfile="testbuilds/opensuse15-cm-build.dockerfile"
614        addhosts = self.local_addhosts(dockerfile)
615        savename = docname(dockerfile)
616        saveto = SAVETO
617        images = IMAGES
618        build = "build --build-arg=no_check=true" + self.nocache()
619        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
620        sh____(cmd.format(**locals()))
621        cmd = "docker rm --force {testname}"
622        sx____(cmd.format(**locals()))
623        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
624        sh____(cmd.format(**locals()))
625        #:# container = self.ip_container(testname)
626        cmd = "docker exec {testname} ls -l /usr/local/bin"
627        sh____(cmd.format(**locals()))
628        cmd = "docker exec {testname} find /usr/local/include -type f"
629        sh____(cmd.format(**locals()))
630        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
631        sh____(cmd.format(**locals()))
632        #
633        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/SDL_rwops_zzip'"
634        sh____(cmd.format(**locals()))
635        cmd = "docker exec {testname} rpm -q --whatprovides /usr/lib64/pkgconfig/zlib.pc"
636        sh____(cmd.format(**locals()))
637        cmd = "docker exec {testname} pkg-config --libs zlib"
638        zlib = output(cmd.format(**locals()))
639        self.assertEqual(zlib.strip(), "-lz")
640        #
641        cmd = "docker rm --force {testname}"
642        sx____(cmd.format(**locals()))
643        cmd = "docker rmi {saveto}/{savename}:latest"
644        sx____(cmd.format(**locals()))
645        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
646        sh____(cmd.format(**locals()))
647        cmd = "docker rmi {images}:{testname}"
648        sx____(cmd.format(**locals()))
649        self.rm_testdir()
650    @unittest.expectedFailure
651    def test_250_windows_static_x64_dockerfile(self):
652        logg.warning("     windows-static-x64 compiles fine but segfaults on linking an .exe")
653        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
654        self.rm_old()
655        self.rm_testdir()
656        testname=self.testname()
657        testdir = self.testdir()
658        dockerfile="testbuilds/windows-static-x64.dockerfile"
659        addhosts = self.local_addhosts(dockerfile)
660        savename = docname(dockerfile)
661        saveto = SAVETO
662        images = IMAGES
663        build = "build --build-arg=no_check=true" + self.nocache()
664        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
665        sh____(cmd.format(**locals()))
666        cmd = "docker rm --force {testname}"
667        sx____(cmd.format(**locals()))
668        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
669        sh____(cmd.format(**locals()))
670        #:# container = self.ip_container(testname)
671        #
672        cmd = "docker exec {testname} ls -l /usr/local/bin"
673        sh____(cmd.format(**locals()))
674        #
675        cmd = "docker rm --force {testname}"
676        sx____(cmd.format(**locals()))
677        cmd = "docker rmi {saveto}/{savename}:latest"
678        sx____(cmd.format(**locals()))
679        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
680        sh____(cmd.format(**locals()))
681        cmd = "docker rmi {images}:{testname}"
682        sx____(cmd.format(**locals()))
683        self.rm_testdir()
684    @unittest.expectedFailure
685    def test_260_windows_shared_x64_dockerfile(self):
686        logg.warning("     windows-shared-x64 compiles fine but segfaults on linking an .exe")
687        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
688        self.rm_old()
689        self.rm_testdir()
690        testname=self.testname()
691        testdir = self.testdir()
692        dockerfile="testbuilds/windows-shared-x64.dockerfile"
693        addhosts = self.local_addhosts(dockerfile)
694        savename = docname(dockerfile)
695        saveto = SAVETO
696        images = IMAGES
697        build = "build --build-arg=no_check=true" + self.nocache()
698        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
699        sh____(cmd.format(**locals()))
700        cmd = "docker rm --force {testname}"
701        sx____(cmd.format(**locals()))
702        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
703        sh____(cmd.format(**locals()))
704        #:# container = self.ip_container(testname)
705        #
706        cmd = "docker exec {testname} ls -l /usr/local/bin"
707        sh____(cmd.format(**locals()))
708        #
709        cmd = "docker rm --force {testname}"
710        sx____(cmd.format(**locals()))
711        cmd = "docker rmi {saveto}/{savename}:latest"
712        sx____(cmd.format(**locals()))
713        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
714        sh____(cmd.format(**locals()))
715        cmd = "docker rmi {images}:{testname}"
716        sx____(cmd.format(**locals()))
717        self.rm_testdir()
718    def test_307_centos7_automake_sdl2_dockerfile(self):
719        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
720        self.rm_old()
721        self.rm_testdir()
722        testname=self.testname()
723        testdir = self.testdir()
724        dockerfile="testbuilds/centos7-am-sdl2.dockerfile"
725        addhosts = self.local_addhosts(dockerfile)
726        savename = docname(dockerfile)
727        saveto = SAVETO
728        images = IMAGES
729        build = "build --build-arg=no_check=true" + self.nocache()
730        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
731        sh____(cmd.format(**locals()))
732        cmd = "docker rm --force {testname}"
733        sx____(cmd.format(**locals()))
734        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
735        sh____(cmd.format(**locals()))
736        #:# container = self.ip_container(testname)
737        cmd = "docker exec {testname} ls -l /usr/local/bin"
738        sh____(cmd.format(**locals()))
739        cmd = "docker exec {testname} find /usr/local/include -type f"
740        sh____(cmd.format(**locals()))
741        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
742        sh____(cmd.format(**locals()))
743        #
744        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
745        sh____(cmd.format(**locals()))
746        #
747        cmd = "docker rm --force {testname}"
748        sx____(cmd.format(**locals()))
749        cmd = "docker rmi {saveto}/{savename}:latest"
750        sx____(cmd.format(**locals()))
751        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
752        sh____(cmd.format(**locals()))
753        cmd = "docker rmi {images}:{testname}"
754        sx____(cmd.format(**locals()))
755        self.rm_testdir()
756    def test_308_centos8_automake_sdl2_dockerfile(self):
757        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
758        self.rm_old()
759        self.rm_testdir()
760        testname=self.testname()
761        testdir = self.testdir()
762        dockerfile="testbuilds/centos8-am-sdl2.dockerfile"
763        addhosts = self.local_addhosts(dockerfile)
764        savename = docname(dockerfile)
765        saveto = SAVETO
766        images = IMAGES
767        build = "build --build-arg=no_check=true" + self.nocache()
768        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
769        sh____(cmd.format(**locals()))
770        cmd = "docker rm --force {testname}"
771        sx____(cmd.format(**locals()))
772        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
773        sh____(cmd.format(**locals()))
774        #:# container = self.ip_container(testname)
775        cmd = "docker exec {testname} ls -l /usr/local/bin"
776        sh____(cmd.format(**locals()))
777        cmd = "docker exec {testname} find /usr/local/include -type f"
778        sh____(cmd.format(**locals()))
779        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
780        sh____(cmd.format(**locals()))
781        #
782        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
783        sh____(cmd.format(**locals()))
784        #
785        cmd = "docker rm --force {testname}"
786        sx____(cmd.format(**locals()))
787        cmd = "docker rmi {saveto}/{savename}:latest"
788        sx____(cmd.format(**locals()))
789        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
790        sh____(cmd.format(**locals()))
791        cmd = "docker rmi {images}:{testname}"
792        sx____(cmd.format(**locals()))
793        self.rm_testdir()
794    def test_317_centos7_cmake_sdl2_dockerfile(self):
795        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
796        self.rm_old()
797        self.rm_testdir()
798        testname=self.testname()
799        testdir = self.testdir()
800        dockerfile="testbuilds/centos7-cm-sdl2.dockerfile"
801        addhosts = self.local_addhosts(dockerfile)
802        savename = docname(dockerfile)
803        saveto = SAVETO
804        images = IMAGES
805        build = "build --build-arg=no_check=true" + self.nocache()
806        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
807        sh____(cmd.format(**locals()))
808        cmd = "docker rm --force {testname}"
809        sx____(cmd.format(**locals()))
810        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
811        sh____(cmd.format(**locals()))
812        #:# container = self.ip_container(testname)
813        cmd = "docker exec {testname} ls -l /usr/local/bin"
814        sh____(cmd.format(**locals()))
815        cmd = "docker exec {testname} find /usr/local/include -type f"
816        sh____(cmd.format(**locals()))
817        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
818        sh____(cmd.format(**locals()))
819        #
820        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
821        sh____(cmd.format(**locals()))
822        #
823        cmd = "docker rm --force {testname}"
824        sx____(cmd.format(**locals()))
825        cmd = "docker rmi {saveto}/{savename}:latest"
826        sx____(cmd.format(**locals()))
827        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
828        sh____(cmd.format(**locals()))
829        cmd = "docker rmi {images}:{testname}"
830        sx____(cmd.format(**locals()))
831        self.rm_testdir()
832    def test_318_centos8_cmake_sdl2_dockerfile(self):
833        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
834        self.rm_old()
835        self.rm_testdir()
836        testname=self.testname()
837        testdir = self.testdir()
838        dockerfile="testbuilds/centos8-cm-sdl2.dockerfile"
839        addhosts = self.local_addhosts(dockerfile)
840        savename = docname(dockerfile)
841        saveto = SAVETO
842        images = IMAGES
843        build = "build --build-arg=no_check=true" + self.nocache()
844        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
845        sh____(cmd.format(**locals()))
846        cmd = "docker rm --force {testname}"
847        sx____(cmd.format(**locals()))
848        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
849        sh____(cmd.format(**locals()))
850        #:# container = self.ip_container(testname)
851        cmd = "docker exec {testname} ls -l /usr/local/bin"
852        sh____(cmd.format(**locals()))
853        cmd = "docker exec {testname} find /usr/local/include -type f"
854        sh____(cmd.format(**locals()))
855        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
856        sh____(cmd.format(**locals()))
857        #
858        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
859        sh____(cmd.format(**locals()))
860        #
861        cmd = "docker rm --force {testname}"
862        sx____(cmd.format(**locals()))
863        cmd = "docker rmi {saveto}/{savename}:latest"
864        sx____(cmd.format(**locals()))
865        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
866        sh____(cmd.format(**locals()))
867        cmd = "docker rmi {images}:{testname}"
868        sx____(cmd.format(**locals()))
869        self.rm_testdir()
870    def test_322_ubuntu18_cmake_sdl2_dockerfile(self):
871        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
872        self.rm_old()
873        self.rm_testdir()
874        testname=self.testname()
875        testdir = self.testdir()
876        dockerfile="testbuilds/ubuntu16-cm-sdl2.dockerfile"
877        addhosts = self.local_addhosts(dockerfile, "--universe")
878        savename = docname(dockerfile)
879        saveto = SAVETO
880        images = IMAGES
881        build = "build --build-arg=no_check=true" + self.nocache()
882        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
883        sh____(cmd.format(**locals()))
884        cmd = "docker rm --force {testname}"
885        sx____(cmd.format(**locals()))
886        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
887        sh____(cmd.format(**locals()))
888        #:# container = self.ip_container(testname)
889        cmd = "docker exec {testname} ls -l /usr/local/bin"
890        sh____(cmd.format(**locals()))
891        cmd = "docker exec {testname} find /usr/local/include -type f"
892        sh____(cmd.format(**locals()))
893        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib/libzz*'"
894        sh____(cmd.format(**locals()))
895        #
896        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
897        sh____(cmd.format(**locals()))
898        #
899        cmd = "docker rm --force {testname}"
900        sx____(cmd.format(**locals()))
901        cmd = "docker rmi {saveto}/{savename}:latest"
902        sx____(cmd.format(**locals()))
903        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
904        sh____(cmd.format(**locals()))
905        cmd = "docker rmi {images}:{testname}"
906        sx____(cmd.format(**locals()))
907        self.rm_testdir()
908    def test_335_opensuse15_cmake_sdl2_dockerfile(self):
909        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
910        self.rm_old()
911        self.rm_testdir()
912        testname=self.testname()
913        testdir = self.testdir()
914        dockerfile="testbuilds/opensuse15-cm-sdl2.dockerfile"
915        addhosts = self.local_addhosts(dockerfile)
916        savename = docname(dockerfile)
917        saveto = SAVETO
918        images = IMAGES
919        build = "build --build-arg=no_check=true" + self.nocache()
920        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
921        sh____(cmd.format(**locals()))
922        cmd = "docker rm --force {testname}"
923        sx____(cmd.format(**locals()))
924        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
925        sh____(cmd.format(**locals()))
926        #:# container = self.ip_container(testname)
927        cmd = "docker exec {testname} ls -l /usr/local/bin"
928        sh____(cmd.format(**locals()))
929        cmd = "docker exec {testname} find /usr/local/include -type f"
930        sh____(cmd.format(**locals()))
931        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
932        sh____(cmd.format(**locals()))
933        #
934        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
935        sh____(cmd.format(**locals()))
936        #
937        cmd = "docker rm --force {testname}"
938        sx____(cmd.format(**locals()))
939        cmd = "docker rmi {saveto}/{savename}:latest"
940        sx____(cmd.format(**locals()))
941        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
942        sh____(cmd.format(**locals()))
943        cmd = "docker rmi {images}:{testname}"
944        sx____(cmd.format(**locals()))
945        self.rm_testdir()
946    def test_417_centos7_cmake_sdl2_destdir_dockerfile(self):
947        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
948        self.rm_old()
949        self.rm_testdir()
950        testname=self.testname()
951        testdir = self.testdir()
952        dockerfile="testbuilds/centos7-cm-destdir-sdl2.dockerfile"
953        addhosts = self.local_addhosts(dockerfile)
954        savename = docname(dockerfile)
955        saveto = SAVETO
956        images = IMAGES
957        build = "build --build-arg=no_check=true" + self.nocache()
958        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
959        sh____(cmd.format(**locals()))
960        cmd = "docker rm --force {testname}"
961        sx____(cmd.format(**locals()))
962        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
963        sh____(cmd.format(**locals()))
964        #:# container = self.ip_container(testname)
965        cmd = "docker exec {testname} ls -l /new/usr/local/bin"
966        sh____(cmd.format(**locals()))
967        cmd = "docker exec {testname} find /new/usr/local/include -type f"
968        sh____(cmd.format(**locals()))
969        cmd = "docker exec {testname} bash -c 'ls -l /new/usr/local/lib64/libzz*'"
970        sh____(cmd.format(**locals()))
971        #
972        cmd = "docker exec {testname} bash -c 'test -d /new/usr/local/include/SDL_rwops_zzip'"
973        sh____(cmd.format(**locals()))
974        #
975        cmd = "docker rm --force {testname}"
976        sx____(cmd.format(**locals()))
977        cmd = "docker rmi {saveto}/{savename}:latest"
978        sx____(cmd.format(**locals()))
979        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
980        sh____(cmd.format(**locals()))
981        cmd = "docker rmi {images}:{testname}"
982        sx____(cmd.format(**locals()))
983        self.rm_testdir()
984    def test_418_centos8_cmake_sdl2_destdir_dockerfile(self):
985        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
986        self.rm_old()
987        self.rm_testdir()
988        testname=self.testname()
989        testdir = self.testdir()
990        dockerfile="testbuilds/centos8-cm-destdir-sdl2.dockerfile"
991        addhosts = self.local_addhosts(dockerfile)
992        savename = docname(dockerfile)
993        saveto = SAVETO
994        images = IMAGES
995        build = "build --build-arg=no_check=true" + self.nocache()
996        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
997        sh____(cmd.format(**locals()))
998        cmd = "docker rm --force {testname}"
999        sx____(cmd.format(**locals()))
1000        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
1001        sh____(cmd.format(**locals()))
1002        #:# container = self.ip_container(testname)
1003        cmd = "docker exec {testname} ls -l /new/usr/local/bin"
1004        sh____(cmd.format(**locals()))
1005        cmd = "docker exec {testname} find /new/usr/local/include -type f"
1006        sh____(cmd.format(**locals()))
1007        cmd = "docker exec {testname} bash -c 'ls -l /new/usr/local/lib64/libzz*'"
1008        sh____(cmd.format(**locals()))
1009        #
1010        cmd = "docker exec {testname} bash -c 'test -d /new/usr/local/include/SDL_rwops_zzip'"
1011        sh____(cmd.format(**locals()))
1012        #
1013        cmd = "docker rm --force {testname}"
1014        sx____(cmd.format(**locals()))
1015        cmd = "docker rmi {saveto}/{savename}:latest"
1016        sx____(cmd.format(**locals()))
1017        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
1018        sh____(cmd.format(**locals()))
1019        cmd = "docker rmi {images}:{testname}"
1020        sx____(cmd.format(**locals()))
1021        self.rm_testdir()
1022    def test_423_ubuntu20_azure_dockerfile(self):
1023        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1024        self.rm_old()
1025        self.rm_testdir()
1026        testname=self.testname()
1027        testdir = self.testdir()
1028        dockerfile="testbuilds/ubuntu20-azure.dockerfile"
1029        addhosts = self.local_addhosts(dockerfile, "--universe")
1030        savename = docname(dockerfile)
1031        saveto = SAVETO
1032        images = IMAGES
1033        build = "build --build-arg=no_install=true" + self.nocache()
1034        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
1035        sh____(cmd.format(**locals()))
1036        cmd = "docker rm --force {testname}"
1037        sx____(cmd.format(**locals()))
1038        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
1039        sh____(cmd.format(**locals()))
1040        #:# container = self.ip_container(testname)
1041        #
1042        cmd = "docker exec {testname} find src -name *.xml"
1043        sh____(cmd.format(**locals()))
1044        #
1045        cmd = "docker rm --force {testname}"
1046        sx____(cmd.format(**locals()))
1047        cmd = "docker rmi {saveto}/{savename}:latest"
1048        sx____(cmd.format(**locals()))
1049        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
1050        sh____(cmd.format(**locals()))
1051        cmd = "docker rmi {images}:{testname}"
1052        sx____(cmd.format(**locals()))
1053        self.rm_testdir()
1054    @unittest.expectedFailure
1055    def test_424_ubuntu20_azure_dockerfile(self):
1056        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1057        self.rm_old()
1058        self.rm_testdir()
1059        dockerfile="testbuilds/ubuntu20-azure.dockerfile" # reusing test_423
1060        savename = docname(dockerfile)
1061        saveto = SAVETO
1062        images = IMAGES
1063        testname=self.testname()
1064        cmd = "docker rm --force {testname}"
1065        sx____(cmd.format(**locals()))
1066        cmd = "docker run -d --name {testname} {saveto}/{savename} sleep 60"
1067        sh____(cmd.format(**locals()))
1068        #:# container = self.ip_container(testname)
1069        #
1070        logg.error("\n\n\t Ubuntu ships 'unzip' that can not handle these CVE zip files .. creating core dumps\n\n")
1071        cmd = "docker exec {testname} bash -c 'cd src/build/test && python3 ../../test/zziptests.py test_65430'"
1072        sh____(cmd.format(**locals()))
1073        cmd = "docker exec {testname} bash -c 'cd src/build/test && python3 ../../test/zziptests.py test_65440'"
1074        sh____(cmd.format(**locals()))
1075        cmd = "docker exec {testname} bash -c 'cd src/build/test && python3 ../../test/zziptests.py test_65480'"
1076        sh____(cmd.format(**locals()))
1077        cmd = "docker exec {testname} bash -c 'cd src/build/test && python3 ../../test/zziptests.py test_65485'"
1078        sh____(cmd.format(**locals()))
1079        #
1080        cmd = "docker rm --force {testname}"
1081        sx____(cmd.format(**locals()))
1082        self.rm_testdir()
1083    def test_435_opensuse15_ninja_sdl2_dockerfile(self):
1084        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1085        self.rm_old()
1086        self.rm_testdir()
1087        testname=self.testname()
1088        testdir = self.testdir()
1089        dockerfile="testbuilds/opensuse15-nj-sdl2.dockerfile"
1090        addhosts = self.local_addhosts(dockerfile)
1091        savename = docname(dockerfile)
1092        saveto = SAVETO
1093        images = IMAGES
1094        build = "build --build-arg=no_check=true" + self.nocache()
1095        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
1096        sh____(cmd.format(**locals()))
1097        cmd = "docker rm --force {testname}"
1098        sx____(cmd.format(**locals()))
1099        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
1100        sh____(cmd.format(**locals()))
1101        #:# container = self.ip_container(testname)
1102        cmd = "docker exec {testname} ls -l /usr/local/bin"
1103        sh____(cmd.format(**locals()))
1104        cmd = "docker exec {testname} find /usr/local/include -type f"
1105        sh____(cmd.format(**locals()))
1106        cmd = "docker exec {testname} bash -c 'ls -l /usr/local/lib64/libzz*'"
1107        sh____(cmd.format(**locals()))
1108        #
1109        cmd = "docker exec {testname} bash -c 'test -d /usr/local/include/SDL_rwops_zzip'"
1110        sh____(cmd.format(**locals()))
1111        #
1112        cmd = "docker rm --force {testname}"
1113        sx____(cmd.format(**locals()))
1114        cmd = "docker rmi {saveto}/{savename}:latest"
1115        sx____(cmd.format(**locals()))
1116        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
1117        sh____(cmd.format(**locals()))
1118        cmd = "docker rmi {images}:{testname}"
1119        sx____(cmd.format(**locals()))
1120        self.rm_testdir()
1121    def test_707_centos7_automake_docs_dockerfile(self):
1122        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1123        self.rm_old()
1124        self.rm_testdir()
1125        testname=self.testname()
1126        testdir = self.testdir()
1127        dockerfile="testbuilds/centos7-am-docs.dockerfile"
1128        addhosts = self.local_addhosts(dockerfile)
1129        savename = docname(dockerfile)
1130        saveto = SAVETO
1131        images = IMAGES
1132        build = "build --build-arg=no_build=true" + self.nocache()
1133        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
1134        sh____(cmd.format(**locals()))
1135        cmd = "docker rm --force {testname}"
1136        sx____(cmd.format(**locals()))
1137        cmd = "docker run -d --name {testname} {images}:{testname} sleep 60"
1138        sh____(cmd.format(**locals()))
1139        #:# container = self.ip_container(testname)
1140        cmd = "docker exec {testname} ls -l /usr/local/bin"
1141        sh____(cmd.format(**locals()))
1142        cmd = "docker exec {testname} find /usr/local/include -type f"
1143        sh____(cmd.format(**locals()))
1144        #
1145        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/zzip/types.h'"
1146        sh____(cmd.format(**locals()))
1147        cmd = "docker exec {testname} bash -c 'test -d /usr/local/share/doc/zziplib'"
1148        sh____(cmd.format(**locals()))
1149        cmd = "docker exec {testname} bash -c 'test -f /usr/local/share/man/man3/zzip_opendir.3'"
1150        sh____(cmd.format(**locals()))
1151        #
1152        cmd = "docker rm --force {testname}"
1153        sx____(cmd.format(**locals()))
1154        cmd = "docker rmi {saveto}/{savename}:latest"
1155        sx____(cmd.format(**locals()))
1156        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
1157        sh____(cmd.format(**locals()))
1158        cmd = "docker rmi {images}:{testname}"
1159        sx____(cmd.format(**locals()))
1160        self.rm_testdir()
1161    def test_717_centos7_cmake_docs_dockerfile(self):
1162        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1163        self.rm_old()
1164        self.rm_testdir()
1165        testname=self.testname()
1166        testdir = self.testdir()
1167        dockerfile="testbuilds/centos7-cm-docs.dockerfile"
1168        addhosts = self.local_addhosts(dockerfile)
1169        savename = docname(dockerfile)
1170        saveto = SAVETO
1171        images = IMAGES
1172        build = "build" # "build --build-arg=no_build=true"
1173        build += self.nocache()
1174        cmd = "docker {build} . -f {dockerfile} {addhosts} --tag {images}:{testname}"
1175        sh____(cmd.format(**locals()))
1176        cmd = "docker rm --force {testname}"
1177        sx____(cmd.format(**locals()))
1178        cmd = "docker run -d --name {testname} {images}:{testname} sleep 600"
1179        sh____(cmd.format(**locals()))
1180        #:# container = self.ip_container(testname)
1181        cmd = "docker exec {testname} ls -l /usr/local/bin"
1182        sh____(cmd.format(**locals()))
1183        cmd = "docker exec {testname} find /usr/local/include -type f"
1184        sh____(cmd.format(**locals()))
1185        #
1186        cmd = "docker exec {testname} bash -c 'test ! -d /usr/local/include/zzip/types.h'"
1187        sh____(cmd.format(**locals()))
1188        cmd = "docker exec {testname} bash -c 'test -d /usr/local/share/doc/zziplib'"
1189        sh____(cmd.format(**locals()))
1190        cmd = "docker exec {testname} bash -c 'test -f /usr/local/share/man/man3/zzip_opendir.3'"
1191        sh____(cmd.format(**locals()))
1192        #
1193        cmd = "docker rm --force {testname}"
1194        sx____(cmd.format(**locals()))
1195        cmd = "docker rmi {saveto}/{savename}:latest"
1196        sx____(cmd.format(**locals()))
1197        cmd = "docker tag {images}:{testname} {saveto}/{savename}:latest"
1198        sh____(cmd.format(**locals()))
1199        cmd = "docker rmi {images}:{testname}"
1200        sx____(cmd.format(**locals()))
1201        self.rm_testdir()
1202    def test_917_centos7_am_cm_dockerfile(self):
1203        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1204        self.rm_old()
1205        self.rm_testdir()
1206        testname1=self.testname() + "_am"
1207        testname2=self.testname() + "_cm"
1208        testdir = self.testdir()
1209        dockerfile1="testbuilds/centos7-am-build.dockerfile" # make st_207
1210        dockerfile2="testbuilds/centos7-cm-build.dockerfile" # make st_217
1211        addhosts = self.local_addhosts(dockerfile1)
1212        savename1 = docname(dockerfile1)
1213        savename2 = docname(dockerfile2)
1214        saveto = SAVETO
1215        images = IMAGES
1216        cmd = "docker rm --force {testname1}"
1217        sx____(cmd.format(**locals()))
1218        cmd = "docker rm --force {testname2}"
1219        sx____(cmd.format(**locals()))
1220        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1221        sh____(cmd.format(**locals()))
1222        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1223        #
1224        sh____(cmd.format(**locals()))
1225        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1226        sh____(cmd.format(**locals()))
1227        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1228        sh____(cmd.format(**locals()))
1229        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1230        sh____(cmd.format(**locals()))
1231        cmd = "rm tmp.local.tgz"
1232        sh____(cmd.format(**locals()))
1233        cmd = "docker exec {testname1} mkdir -p /new/local"
1234        sh____(cmd.format(**locals()))
1235        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1236        sh____(cmd.format(**locals()))
1237        #
1238        item="{}"
1239        end="\\;"
1240        A='"s:zzip-zlib-config:zlib:"'
1241        B='"s:=/usr/local/:=\\${prefix}/:"'
1242        C1='"/^exec_prefix=/d"'
1243        C2='"/^datarootdir=/d"'
1244        C3='"/^datadir=/d"'
1245        C4='"/^sysconfdir=/d"'
1246        C5='"/^bindir=/d"'
1247        G='"/ generated by configure /d"'
1248        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.pc -exec sed -i -e {A} -e {B} -e {C1} -e {C2} -e {C3} -e {C4} -e {C5} -e {G} {item} {end}'"
1249        sh____(cmd.format(**locals()))
1250        cmd = "docker exec {testname1} bash -c 'find /usr/local -name zzip-zlib-config.pc -exec rm -v {item} {end}'"
1251        sh____(cmd.format(**locals()))
1252        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.la -exec rm -v {item} {end}'"
1253        sh____(cmd.format(**locals()))
1254        cmd = "docker exec {testname1} bash -c 'find /new/local -name *-0.so -exec rm -v {item} {end}'"
1255        sh____(cmd.format(**locals()))
1256        cmd = "docker exec {testname1} diff -uw /usr/local/include/zzip/_config.h /new/local/include/zzip/_config.h"
1257        sx____(cmd.format(**locals()))
1258        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local --exclude _config.h"
1259        sx____(cmd.format(**locals()))
1260        out = output(cmd.format(**locals()))
1261        if "---" in out or "Only" in out:
1262            logg.warning("out>>\n%s", out)
1263        self.assertFalse(greps(out, "---"))
1264        self.assertFalse(greps(out, "Only"))
1265        #
1266        cmd = "docker rm --force {testname1}"
1267        sx____(cmd.format(**locals()))
1268        cmd = "docker rm --force {testname2}"
1269        sx____(cmd.format(**locals()))
1270        self.rm_testdir()
1271    def test_918_centos8_am_cm_dockerfile(self):
1272        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1273        self.rm_old()
1274        self.rm_testdir()
1275        testname1=self.testname() + "_am"
1276        testname2=self.testname() + "_cm"
1277        testdir = self.testdir()
1278        dockerfile1="testbuilds/centos8-am-build.dockerfile" # make st_208
1279        dockerfile2="testbuilds/centos8-cm-build.dockerfile" # make st_218
1280        addhosts = self.local_addhosts(dockerfile1)
1281        savename1 = docname(dockerfile1)
1282        savename2 = docname(dockerfile2)
1283        saveto = SAVETO
1284        images = IMAGES
1285        cmd = "docker rm --force {testname1}"
1286        sx____(cmd.format(**locals()))
1287        cmd = "docker rm --force {testname2}"
1288        sx____(cmd.format(**locals()))
1289        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1290        sh____(cmd.format(**locals()))
1291        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1292        #
1293        sh____(cmd.format(**locals()))
1294        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1295        sh____(cmd.format(**locals()))
1296        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1297        sh____(cmd.format(**locals()))
1298        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1299        sh____(cmd.format(**locals()))
1300        cmd = "rm tmp.local.tgz"
1301        sh____(cmd.format(**locals()))
1302        cmd = "docker exec {testname1} mkdir -p /new/local"
1303        sh____(cmd.format(**locals()))
1304        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1305        sh____(cmd.format(**locals()))
1306        #
1307        item="{}"
1308        end="\\;"
1309        A='"s:zzip-zlib-config:zlib:"'
1310        B='"s:=/usr/local/:=\\${prefix}/:"'
1311        C1='"/^exec_prefix=/d"'
1312        C2='"/^datarootdir=/d"'
1313        C3='"/^datadir=/d"'
1314        C4='"/^sysconfdir=/d"'
1315        C5='"/^bindir=/d"'
1316        G='"/ generated by configure /d"'
1317        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.pc -exec sed -i -e {A} -e {B} -e {C1} -e {C2} -e {C3} -e {C4} -e {C5} -e {G} {item} {end}'"
1318        sh____(cmd.format(**locals()))
1319        cmd = "docker exec {testname1} bash -c 'find /usr/local -name zzip-zlib-config.pc -exec rm -v {item} {end}'"
1320        sh____(cmd.format(**locals()))
1321        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.la -exec rm -v {item} {end}'"
1322        sh____(cmd.format(**locals()))
1323        cmd = "docker exec {testname1} bash -c 'find /new/local -name *-0.so -exec rm -v {item} {end}'"
1324        sh____(cmd.format(**locals()))
1325        cmd = "docker exec {testname1} diff -uw /usr/local/include/zzip/_config.h /new/local/include/zzip/_config.h"
1326        sx____(cmd.format(**locals()))
1327        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local --exclude _config.h"
1328        sx____(cmd.format(**locals()))
1329        out = output(cmd.format(**locals()))
1330        if "---" in out or "Only" in out:
1331            logg.warning("out>>\n%s", out)
1332        self.assertFalse(greps(out, "---"))
1333        self.assertFalse(greps(out, "Only"))
1334        #
1335        cmd = "docker rm --force {testname1}"
1336        sx____(cmd.format(**locals()))
1337        cmd = "docker rm --force {testname2}"
1338        sx____(cmd.format(**locals()))
1339        self.rm_testdir()
1340    def test_937_centos7_am_cm_sdl2_dockerfile(self):
1341        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1342        self.rm_old()
1343        self.rm_testdir()
1344        testname1=self.testname() + "_am"
1345        testname2=self.testname() + "_cm"
1346        testdir = self.testdir()
1347        dockerfile1="testbuilds/centos7-am-sdl2.dockerfile" # make st_307
1348        dockerfile2="testbuilds/centos7-cm-sdl2.dockerfile" # make st_317
1349        addhosts = self.local_addhosts(dockerfile1)
1350        savename1 = docname(dockerfile1)
1351        savename2 = docname(dockerfile2)
1352        saveto = SAVETO
1353        images = IMAGES
1354        cmd = "docker rm --force {testname1}"
1355        sx____(cmd.format(**locals()))
1356        cmd = "docker rm --force {testname2}"
1357        sx____(cmd.format(**locals()))
1358        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1359        sh____(cmd.format(**locals()))
1360        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1361        #
1362        sh____(cmd.format(**locals()))
1363        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1364        sh____(cmd.format(**locals()))
1365        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1366        sh____(cmd.format(**locals()))
1367        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1368        sh____(cmd.format(**locals()))
1369        cmd = "rm tmp.local.tgz"
1370        sh____(cmd.format(**locals()))
1371        cmd = "docker exec {testname1} mkdir -p /new/local"
1372        sh____(cmd.format(**locals()))
1373        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1374        sh____(cmd.format(**locals()))
1375        #
1376        item="{}"
1377        end="\\;"
1378        A='"s:zzip-zlib-config:zlib:"'
1379        B='"s:=/usr/local/:=\\${prefix}/:"'
1380        C1='"/^exec_prefix=/d"'
1381        C2='"/^datarootdir=/d"'
1382        C3='"/^datadir=/d"'
1383        C4='"/^sysconfdir=/d"'
1384        C5='"/^bindir=/d"'
1385        G='"/ generated by configure /d"'
1386        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.pc -exec sed -i -e {A} -e {B} -e {C1} -e {C2} -e {C3} -e {C4} -e {C5} -e {G} {item} {end}'"
1387        sh____(cmd.format(**locals()))
1388        cmd = "docker exec {testname1} bash -c 'find /usr/local -name zzip-zlib-config.pc -exec rm -v {item} {end}'"
1389        sh____(cmd.format(**locals()))
1390        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.la -exec rm -v {item} {end}'"
1391        sh____(cmd.format(**locals()))
1392        cmd = "docker exec {testname1} bash -c 'find /new/local -name *-0.so -exec rm -v {item} {end}'"
1393        sh____(cmd.format(**locals()))
1394        cmd = "docker exec {testname1} diff -uw /usr/local/include/zzip/_config.h /new/local/include/zzip/_config.h"
1395        sx____(cmd.format(**locals()))
1396        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local --exclude _config.h"
1397        sx____(cmd.format(**locals()))
1398        out = output(cmd.format(**locals()))
1399        if "---" in out or "Only" in out:
1400            logg.warning("out>>\n%s", out)
1401        self.assertFalse(greps(out, "---"))
1402        self.assertFalse(greps(out, "Only"))
1403        #
1404        cmd = "docker rm --force {testname1}"
1405        sx____(cmd.format(**locals()))
1406        cmd = "docker rm --force {testname2}"
1407        sx____(cmd.format(**locals()))
1408        self.rm_testdir()
1409    def test_938_centos8_am_cm_sdl2_dockerfile(self):
1410        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1411        self.rm_old()
1412        self.rm_testdir()
1413        testname1=self.testname() + "_am"
1414        testname2=self.testname() + "_cm"
1415        testdir = self.testdir()
1416        dockerfile1="testbuilds/centos8-am-sdl2.dockerfile" # make st_308
1417        dockerfile2="testbuilds/centos8-cm-sdl2.dockerfile" # make st_318
1418        addhosts = self.local_addhosts(dockerfile1)
1419        savename1 = docname(dockerfile1)
1420        savename2 = docname(dockerfile2)
1421        saveto = SAVETO
1422        images = IMAGES
1423        cmd = "docker rm --force {testname1}"
1424        sx____(cmd.format(**locals()))
1425        cmd = "docker rm --force {testname2}"
1426        sx____(cmd.format(**locals()))
1427        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1428        sh____(cmd.format(**locals()))
1429        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1430        #
1431        sh____(cmd.format(**locals()))
1432        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1433        sh____(cmd.format(**locals()))
1434        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1435        sh____(cmd.format(**locals()))
1436        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1437        sh____(cmd.format(**locals()))
1438        cmd = "rm tmp.local.tgz"
1439        sh____(cmd.format(**locals()))
1440        cmd = "docker exec {testname1} mkdir -p /new/local"
1441        sh____(cmd.format(**locals()))
1442        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1443        sh____(cmd.format(**locals()))
1444        #
1445        item="{}"
1446        end="\\;"
1447        A='"s:zzip-zlib-config:zlib:"'
1448        B='"s:=/usr/local/:=\\${prefix}/:"'
1449        C1='"/^exec_prefix=/d"'
1450        C2='"/^datarootdir=/d"'
1451        C3='"/^datadir=/d"'
1452        C4='"/^sysconfdir=/d"'
1453        C5='"/^bindir=/d"'
1454        G='"/ generated by configure /d"'
1455        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.pc -exec sed -i -e {A} -e {B} -e {C1} -e {C2} -e {C3} -e {C4} -e {C5} -e {G} {item} {end}'"
1456        sh____(cmd.format(**locals()))
1457        cmd = "docker exec {testname1} bash -c 'find /usr/local -name zzip-zlib-config.pc -exec rm -v {item} {end}'"
1458        sh____(cmd.format(**locals()))
1459        cmd = "docker exec {testname1} bash -c 'find /usr/local -name *.la -exec rm -v {item} {end}'"
1460        sh____(cmd.format(**locals()))
1461        cmd = "docker exec {testname1} bash -c 'find /new/local -name *-0.so -exec rm -v {item} {end}'"
1462        sh____(cmd.format(**locals()))
1463        cmd = "docker exec {testname1} diff -uw /usr/local/include/zzip/_config.h /new/local/include/zzip/_config.h"
1464        sx____(cmd.format(**locals()))
1465        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local --exclude _config.h"
1466        sx____(cmd.format(**locals()))
1467        out = output(cmd.format(**locals()))
1468        if "---" in out or "Only" in out:
1469            logg.warning("out>>\n%s", out)
1470        self.assertFalse(greps(out, "---"))
1471        self.assertFalse(greps(out, "Only"))
1472        #
1473        cmd = "docker rm --force {testname1}"
1474        sx____(cmd.format(**locals()))
1475        cmd = "docker rm --force {testname2}"
1476        sx____(cmd.format(**locals()))
1477        self.rm_testdir()
1478    def test_947_centos7_cm_sdl2_or_destdir_dockerfile(self):
1479        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1480        self.rm_old()
1481        self.rm_testdir()
1482        testname1=self.testname() + "_usr"
1483        testname2=self.testname() + "_new"
1484        testdir = self.testdir()
1485        dockerfile1="testbuilds/centos7-cm-sdl2.dockerfile"          # make st_317
1486        dockerfile2="testbuilds/centos7-cm-destdir-sdl2.dockerfile"  # make st_417
1487        addhosts = self.local_addhosts(dockerfile1)
1488        savename1 = docname(dockerfile1)
1489        savename2 = docname(dockerfile2)
1490        saveto = SAVETO
1491        images = IMAGES
1492        cmd = "docker rm --force {testname1}"
1493        sx____(cmd.format(**locals()))
1494        cmd = "docker rm --force {testname2}"
1495        sx____(cmd.format(**locals()))
1496        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1497        sh____(cmd.format(**locals()))
1498        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1499        #
1500        sh____(cmd.format(**locals()))
1501        cmd = "docker exec {testname2} bash -c 'cd /new/usr/local && tar czvf /local.tgz .'"
1502        sh____(cmd.format(**locals()))
1503        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1504        sh____(cmd.format(**locals()))
1505        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1506        sh____(cmd.format(**locals()))
1507        cmd = "rm tmp.local.tgz"
1508        sh____(cmd.format(**locals()))
1509        cmd = "docker exec {testname1} mkdir -p /new/local"
1510        sh____(cmd.format(**locals()))
1511        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1512        sh____(cmd.format(**locals()))
1513        #
1514        DIRS="etc lib libexec sbin games src share/info share/applications share/man/mann"
1515        for i in xrange(1,10):
1516           DIRS+=" share/man/man%i share/man/man%ix" % (i,i)
1517        cmd = "docker exec {testname1} bash -c 'cd /new/local && (for u in {DIRS}; do mkdir -pv $u; done)'"
1518        sh____(cmd.format(**locals()))
1519        item="{}"
1520        end="\\;"
1521        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local"
1522        sx____(cmd.format(**locals()))
1523        out = output(cmd.format(**locals()))
1524        if "---" in out or "Only" in out:
1525            logg.warning("out>>\n%s", out)
1526        self.assertFalse(greps(out, "---"))
1527        self.assertFalse(greps(out, "Only"))
1528        #
1529        cmd = "docker rm --force {testname1}"
1530        sx____(cmd.format(**locals()))
1531        cmd = "docker rm --force {testname2}"
1532        sx____(cmd.format(**locals()))
1533        self.rm_testdir()
1534    def test_948_centos8_cm_sdl2_or_destdir_dockerfile(self):
1535        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1536        self.rm_old()
1537        self.rm_testdir()
1538        testname1=self.testname() + "_usr"
1539        testname2=self.testname() + "_new"
1540        testdir = self.testdir()
1541        dockerfile1="testbuilds/centos8-cm-sdl2.dockerfile"          # make st_318
1542        dockerfile2="testbuilds/centos8-cm-destdir-sdl2.dockerfile"  # make st_418
1543        addhosts = self.local_addhosts(dockerfile1)
1544        savename1 = docname(dockerfile1)
1545        savename2 = docname(dockerfile2)
1546        saveto = SAVETO
1547        images = IMAGES
1548        cmd = "docker rm --force {testname1}"
1549        sx____(cmd.format(**locals()))
1550        cmd = "docker rm --force {testname2}"
1551        sx____(cmd.format(**locals()))
1552        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1553        sh____(cmd.format(**locals()))
1554        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1555        #
1556        sh____(cmd.format(**locals()))
1557        cmd = "docker exec {testname2} bash -c 'cd /new/usr/local && tar czvf /local.tgz .'"
1558        sh____(cmd.format(**locals()))
1559        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1560        sh____(cmd.format(**locals()))
1561        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1562        sh____(cmd.format(**locals()))
1563        cmd = "rm tmp.local.tgz"
1564        sh____(cmd.format(**locals()))
1565        cmd = "docker exec {testname1} mkdir -p /new/local"
1566        sh____(cmd.format(**locals()))
1567        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1568        sh____(cmd.format(**locals()))
1569        #
1570        DIRS="etc lib libexec sbin games src share/info share/applications share/man/mann"
1571        for i in xrange(1,10):
1572           DIRS+=" share/man/man%i share/man/man%ix" % (i,i)
1573        cmd = "docker exec {testname1} bash -c 'cd /new/local && (for u in {DIRS}; do mkdir -pv $u; done)'"
1574        sh____(cmd.format(**locals()))
1575        item="{}"
1576        end="\\;"
1577        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local"
1578        sx____(cmd.format(**locals()))
1579        out = output(cmd.format(**locals()))
1580        if "---" in out or "Only" in out:
1581            logg.warning("out>>\n%s", out)
1582        self.assertFalse(greps(out, "---"))
1583        self.assertFalse(greps(out, "Only"))
1584        #
1585        cmd = "docker rm --force {testname1}"
1586        sx____(cmd.format(**locals()))
1587        cmd = "docker rm --force {testname2}"
1588        sx____(cmd.format(**locals()))
1589        self.rm_testdir()
1590    def test_965_opensuse_cm_or_nj_sdl2_dockerfile(self):
1591        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1592        self.rm_old()
1593        self.rm_testdir()
1594        testname1=self.testname() + "_cm"
1595        testname2=self.testname() + "_nj"
1596        testdir = self.testdir()
1597        dockerfile1="testbuilds/opensuse15-cm-sdl2.dockerfile"  # make st_335
1598        dockerfile2="testbuilds/opensuse15-nj-sdl2.dockerfile"  # make st_435
1599        addhosts = self.local_addhosts(dockerfile1)
1600        savename1 = docname(dockerfile1)
1601        savename2 = docname(dockerfile2)
1602        saveto = SAVETO
1603        images = IMAGES
1604        cmd = "docker rm --force {testname1}"
1605        sx____(cmd.format(**locals()))
1606        cmd = "docker rm --force {testname2}"
1607        sx____(cmd.format(**locals()))
1608        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1609        sh____(cmd.format(**locals()))
1610        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1611        #
1612        sh____(cmd.format(**locals()))
1613        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1614        sh____(cmd.format(**locals()))
1615        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1616        sh____(cmd.format(**locals()))
1617        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1618        sh____(cmd.format(**locals()))
1619        cmd = "rm tmp.local.tgz"
1620        sh____(cmd.format(**locals()))
1621        cmd = "docker exec {testname1} mkdir -p /new/local"
1622        sh____(cmd.format(**locals()))
1623        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1624        sh____(cmd.format(**locals()))
1625        #
1626        item="{}"
1627        end="\\;"
1628        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local"
1629        sx____(cmd.format(**locals()))
1630        out = output(cmd.format(**locals()))
1631        if "---" in out or "Only" in out:
1632            logg.warning("out>>\n%s", out)
1633        self.assertFalse(greps(out, "---"))
1634        self.assertFalse(greps(out, "Only"))
1635        #
1636        cmd = "docker rm --force {testname1}"
1637        sx____(cmd.format(**locals()))
1638        cmd = "docker rm --force {testname2}"
1639        sx____(cmd.format(**locals()))
1640        self.rm_testdir()
1641    def test_977_centos7_am_cm_docs_dockerfile(self):
1642        if not os.path.exists(DOCKER_SOCKET): self.skipTest("docker-based test")
1643        self.rm_old()
1644        self.rm_testdir()
1645        testname1=self.testname() + "_am"
1646        testname2=self.testname() + "_cm"
1647        testdir = self.testdir()
1648        dockerfile1="testbuilds/centos7-am-docs.dockerfile"
1649        dockerfile2="testbuilds/centos7-cm-docs.dockerfile"
1650        addhosts = self.local_addhosts(dockerfile1)
1651        savename1 = docname(dockerfile1)
1652        savename2 = docname(dockerfile2)
1653        saveto = SAVETO
1654        images = IMAGES
1655        cmd = "docker rm --force {testname1}"
1656        sx____(cmd.format(**locals()))
1657        cmd = "docker rm --force {testname2}"
1658        sx____(cmd.format(**locals()))
1659        cmd = "docker run -d --name {testname1} {addhosts} {saveto}/{savename1} sleep 600"
1660        sh____(cmd.format(**locals()))
1661        cmd = "docker run -d --name {testname2} {addhosts} {saveto}/{savename2} sleep 600"
1662        #
1663        sh____(cmd.format(**locals()))
1664        cmd = "docker exec {testname2} bash -c 'cd /usr/local && tar czvf /local.tgz .'"
1665        sh____(cmd.format(**locals()))
1666        cmd = "docker cp {testname2}:/local.tgz tmp.local.tgz"
1667        sh____(cmd.format(**locals()))
1668        cmd = "docker cp tmp.local.tgz {testname1}:/local.tgz"
1669        sh____(cmd.format(**locals()))
1670        cmd = "rm tmp.local.tgz"
1671        sh____(cmd.format(**locals()))
1672        cmd = "docker exec {testname1} mkdir -p /new/local"
1673        sh____(cmd.format(**locals()))
1674        cmd = "docker exec {testname1} bash -c 'cd /new/local && tar xzvf /local.tgz'"
1675        sh____(cmd.format(**locals()))
1676        #
1677        cmd = "docker exec {testname1} bash -c 'cd /usr/local/share/doc/zziplib && mv man/html .'"
1678        sh____(cmd.format(**locals()))
1679        cmd = "docker exec {testname1} bash -c 'cd /usr/local/share/doc/zziplib && rm -rf man'"
1680        sh____(cmd.format(**locals()))
1681        cmd = "docker exec {testname1} bash -c 'cd /usr/local/share/doc/zziplib && mv html man'"
1682        sh____(cmd.format(**locals()))
1683        item="{}"
1684        end="\\;"
1685        cmd = "docker exec {testname1} diff -urw --no-dereference --brief /usr/local /new/local"
1686        sx____(cmd.format(**locals()))
1687        out = output(cmd.format(**locals()))
1688        if "---" in out or "Only" in out:
1689            logg.warning("out>>\n%s", out)
1690        self.assertFalse(greps(out, "---"))
1691        self.assertFalse(greps(out, "Only"))
1692        #
1693        cmd = "docker exec {testname1} diff -urw --no-dereference /usr/local /new/local"
1694        sx____(cmd.format(**locals()))
1695        #
1696        cmd = "docker rm --force {testname1}"
1697        sx____(cmd.format(**locals()))
1698        cmd = "docker rm --force {testname2}"
1699        sx____(cmd.format(**locals()))
1700        self.rm_testdir()
1701
1702
1703if __name__ == "__main__":
1704    from optparse import OptionParser
1705    _o = OptionParser("%prog [options] test*",
1706       epilog=__doc__.strip().split("\n")[0])
1707    _o.add_option("-v","--verbose", action="count", default=0,
1708       help="increase logging level [%default]")
1709    _o.add_option("-p","--python", metavar="EXE", default=_python,
1710       help="use another python execution engine [%default]")
1711    _o.add_option("-D","--docker", metavar="EXE", default=DOCKER,
1712       help="use another docker execution engine [%default]")
1713    _o.add_option("-M","--mirror", metavar="EXE", default=MIRROR,
1714       help="use another docker_mirror.py script [%default]")
1715    _o.add_option("-f","--force", action="count", default=0,
1716       help="force the rebuild steps [%default]")
1717    _o.add_option("-x","--no-cache", action="count", default=0,
1718       help="force docker build --no-cache [%default]")
1719    _o.add_option("-l","--logfile", metavar="FILE", default="",
1720       help="additionally save the output log to a file [%default]")
1721    _o.add_option("--xmlresults", metavar="FILE", default=None,
1722       help="capture results as a junit xml file [%default]")
1723    opt, args = _o.parse_args()
1724    logging.basicConfig(level = logging.WARNING - opt.verbose * 5)
1725    #
1726    _python = opt.python
1727    DOCKER = opt.docker
1728    MIRROR = opt.mirror
1729    FORCE = opt.force
1730    NOCACHE = opt.no_cache
1731    #
1732    logfile = None
1733    if opt.logfile:
1734        if os.path.exists(opt.logfile):
1735           os.remove(opt.logfile)
1736        logfile = logging.FileHandler(opt.logfile)
1737        logfile.setFormatter(logging.Formatter("%(levelname)s:%(relativeCreated)d:%(message)s"))
1738        logging.getLogger().addHandler(logfile)
1739        logg.info("log diverted to %s", opt.logfile)
1740    xmlresults = None
1741    if opt.xmlresults:
1742        if os.path.exists(opt.xmlresults):
1743           os.remove(opt.xmlresults)
1744        xmlresults = open(opt.xmlresults, "w")
1745        logg.info("xml results into %s", opt.xmlresults)
1746    #
1747    # unittest.main()
1748    suite = unittest.TestSuite()
1749    if not args: args = [ "test_*" ]
1750    for arg in args:
1751        for classname in sorted(globals()):
1752            if not classname.endswith("Test"):
1753                continue
1754            testclass = globals()[classname]
1755            for method in sorted(dir(testclass)):
1756                if "*" not in arg: arg += "*"
1757                if arg.startswith("_"): arg = arg[1:]
1758                if fnmatch(method, arg):
1759                    suite.addTest(testclass(method))
1760    # select runner
1761    if not logfile:
1762        if xmlresults:
1763            import xmlrunner
1764            Runner = xmlrunner.XMLTestRunner
1765            Runner(xmlresults).run(suite)
1766        else:
1767            Runner = unittest.TextTestRunner
1768            Runner(verbosity=opt.verbose).run(suite)
1769    else:
1770        Runner = unittest.TextTestRunner
1771        if xmlresults:
1772            import xmlrunner
1773            Runner = xmlrunner.XMLTestRunner
1774        Runner(logfile.stream, verbosity=opt.verbose).run(suite)
1775