def run_tests(self, experiment, run): """Runs runtime tests for eix""" wrap(path.join("usr", "bin", "eix"), experiment, self.builddir) eix = uchroot()["/usr/bin/eix"] run(eix["clang"])
def run_tests(self, experiment, run): mozjs_dir = path.join("mozjs-0.0.0", "js", "src", "obj") wrap(path.join(mozjs_dir, "js", "src", "shell", "js"), partial(experiment, may_wrap=False)) with local.cwd(mozjs_dir): run(make["check-jstests"])
def run_tests(self, runner): mozjs_dir = path.join("mozjs-0.0.0", "js", "src", "obj") self.runtime_extension = partial(self, may_wrap=False) wrap(path.join(mozjs_dir, "js", "src", "shell", "js"), self) with local.cwd(mozjs_dir): run(make["check-jstests"])
def run_tests(self, runner): unpack_dir = local.path('tcc-{0}.tar.bz2'.format(self.version)) with local.cwd(unpack_dir): with local.cwd("build"): wrapping.wrap("tcc", self) inc_path = path.abspath("..") runner(make["TCCFLAGS=-B{}".format(inc_path), "test", "-i"])
def run_tests(self, runner): with local.cwd(path.join(self.src_dir, "tests")): for binary in LibreSSL.BINARIES: wrap(path.abspath(binary), self) with local.cwd(self.src_dir): run(make["V=1", "check", "-i"])
def run_tests(self, runner): def filter_stderr(stderr_raw, stderr_filtered): """Extract dump_arrays_output from stderr.""" with open(stderr_raw, 'r') as stderr: with open(stderr_filtered, 'w') as stderr_filt: stderr_filt.writelines( get_dump_arrays_output(stderr.readlines())) polybench_opts = CFG["projects"]["polybench"] verify = bool(polybench_opts["verify"]) binary = local.cwd / self.name opt_stderr_raw = binary + ".stderr" opt_stderr_filtered = opt_stderr_raw + ".filtered" runner(wrapping.wrap(binary, self)) filter_stderr(opt_stderr_raw, opt_stderr_filtered) if verify: binary = local.cwd / (self.name + ".no-opts") noopt_stderr_raw = binary + ".stderr" noopt_stderr_filtered = noopt_stderr_raw + ".filtered" with local.env(BB_IS_BASELINE=True): runner(wrapping.wrap(binary, self)) filter_stderr(noopt_stderr_raw, noopt_stderr_filtered) diff_cmd = diff[noopt_stderr_filtered, opt_stderr_filtered] runner(diff_cmd, retcode=0)
def run_tests(self, runner): for outfile in self.config['src']: wrap(os.path.join(self.in_src_dir, outfile), self) with local.cwd(self.in_src_dir): test_runner = sh["./run"] runner(test_runner)
def run_tests(self, runner): mcrypt_dir = local.path(self.builddir) / "mcrypt-2.6.8" mcrypt_libs = mcrypt_dir / "src" / ".libs" aestest = wrapping.wrap(mcrypt_libs / "lt-aestest", self) ciphertest = wrapping.wrap(mcrypt_libs / "lt-ciphertest", self) run.run(aestest) run.run(ciphertest)
def run_tests(self, runner): noopts_file = self.run_f + ".no-opts" noopts_file_stderr = noopts_file + ".stderr" noopts_file_stderr_2 = noopts_file_stderr + ".2" opts_file = self.run_f opts_file_stderr = self.run_f + ".stderr" opts_file_stderr_2 = opts_file_stderr + ".2" runner(wrap(opts_file, self)) with local.env(BB_IS_BASELINE=True): runner(wrap(noopts_file, self)) with open(noopts_file_stderr, 'r') as inf: stderr = inf.readlines() with open(noopts_file_stderr_2, 'w') as fd_stderr: fd_stderr.writelines(get_dump_arrays_output(stderr)) with open(opts_file_stderr, 'r') as inf: stderr = inf.readlines() with open(opts_file_stderr_2, 'w') as fd_stderr: fd_stderr.writelines(get_dump_arrays_output(stderr)) diff_cmd = diff[noopts_file_stderr_2, opts_file_stderr_2] runner(diff_cmd, retcode=0)
def run_tests(self, runner): mozjs_obj_dir = local.path("mozjs-0.0.0") / "js" / "src" / "obj" self.runtime_extension = partial(self, may_wrap=False) wrapping.wrap(mozjs_obj_dir / "js" / "src" / "shell" / "js", self) with local.cwd(mozjs_obj_dir): runner(make["check-jstests"])
def run_tests(self, experiment, run): with local.cwd(path.join(self.src_dir, "tests", ".libs")): files = find(".", "-type", "f", "-executable") for wrap_f in files.split("\n"): if wrap_f: wrap(wrap_f, experiment) with local.cwd(self.src_dir): run(make["V=1", "check"])
def run_tests(self, runner): unpack_dir = local.path("libressl-{0}".format(self.version)) with local.cwd(unpack_dir / "tests"): for binary in LibreSSL.BINARIES: wrapping.wrap(local.cwd / binary, self) with local.cwd(unpack_dir): runner(make["V=1", "check", "-i"])
def run_tests(self, runner): unpack_dir = local.path('rodinia_{0}'.format(self.version)) in_src_dir = unpack_dir / self.config['dir'] for outfile in self.config['src']: wrapping.wrap(in_src_dir / outfile, self) with local.cwd(in_src_dir): runner(sh['./run'])
def run_tests(self, experiment, run): wrap(path.join(self.builddir, "usr/bin/lmp_serial"), experiment, self.builddir) lammps = uchroot()["/usr/bin/lmp_serial"] lammps_dir = path.join(self.builddir, "lammps") with local.cwd("lammps"): tests = glob(path.join(lammps_dir, "in.*")) for test in tests: run((lammps < strip_path_prefix(test, self.builddir)))
def run_tests(self, runner): unpack_dir = "crafty.src" with local.cwd(unpack_dir): crafty = wrapping.wrap("./crafty", self) testdir = local.path(self.testdir) runner((cat[testdir / "test1.sh"] | crafty), retcode=[0, 120]) runner((cat[testdir / "test2.sh"] | crafty), retcode=[0, 120])
def run_tests(self, runner): with local.cwd(self.src_dir): exp = wrap("./crafty", self) runner((cat[path.join(self.testdir, "test1.sh")] | exp), retcode=[0, 120]) runner((cat[path.join(self.testdir, "test2.sh")] | exp), retcode=[0, 120])
def run_tests(self, runner): leveldb_dir = "leveldb.src" with local.cwd(leveldb_dir): with local.env(LD_LIBRARY_PATH=path.abspath(self.src_dir)): sqlite = wrap(path.join("out-static", "db_bench_sqlite3"), self) run(sqlite)
def run_tests(self, runner): leveldb_dir = local.path("leveldb.src") with local.cwd(leveldb_dir): with local.env(LD_LIBRARY_PATH=leveldb_dir): sqlite = wrapping.wrap( leveldb_dir / 'out-static' / 'db_bench_sqlite3', self) run.run(sqlite)
def run_tests(self, runner): crocopat = wrapping.wrap(self.run_f, self) programs = local.path(self.testdir) / "programs" // "*.rml" projects = local.path(self.testdir) / "projects" // "*.rsf" for program in programs: for _project in projects: runner((cat[_project] | crocopat[program]), None)
def run_tests(self, runner): exp = wrap(self.run_f, self) programs = glob(path.join(self.testdir, "programs", "*.rml")) projects = glob(path.join(self.testdir, "projects", "*.rsf")) for program in programs: for project in projects: runner((cat[project] | exp[program]), None)
def run_tests(self, runner): wrap(path.join(self.builddir, "bin", "gzip"), self, self.builddir) gzip = uchroot()["/bin/gzip"] # Compress runner(gzip["-f", "-k", "--best", "compression/text.html"]) runner(gzip["-f", "-k", "--best", "compression/chicken.jpg"]) runner(gzip["-f", "-k", "--best", "compression/control"]) runner(gzip["-f", "-k", "--best", "compression/input.source"]) runner(gzip["-f", "-k", "--best", "compression/liberty.jpg"]) # Decompress runner(gzip["-f", "-k", "--decompress", "compression/text.html.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/chicken.jpg.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/control.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/input.source.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/liberty.jpg.gz"])
def run_tests(self, experiment, run): wrap(path.join(self.builddir, "bin", "bzip2"), experiment, self.builddir) bzip2 = uchroot()["/bin/bzip2"] # Compress run(bzip2["-f", "-z", "-k", "--best", "compression/text.html"]) run(bzip2["-f", "-z", "-k", "--best", "compression/chicken.jpg"]) run(bzip2["-f", "-z", "-k", "--best", "compression/control"]) run(bzip2["-f", "-z", "-k", "--best", "compression/input.source"]) run(bzip2["-f", "-z", "-k", "--best", "compression/liberty.jpg"]) # Decompress run(bzip2["-f", "-k", "--decompress", "compression/text.html.bz2"]) run(bzip2["-f", "-k", "--decompress", "compression/chicken.jpg.bz2"]) run(bzip2["-f", "-k", "--decompress", "compression/control.bz2"]) run(bzip2["-f", "-k", "--decompress", "compression/input.source.bz2"]) run(bzip2["-f", "-k", "--decompress", "compression/liberty.jpg.bz2"])
def run_tests(self, experiment, run): lammps_dir = path.join(self.builddir, self.src_dir, "src") exp = wrap(path.join(lammps_dir, "lmp_serial"), experiment) with local.cwd("test"): tests = glob(path.join(self.testdir, "in.*")) for test in tests: cmd = (exp < test) run(cmd, None)
def run_tests(self, runner): builddir = self.builddir lammps = wrapping.wrap(local.path('/usr/bin/lmp'), self) lammps_dir = builddir / "lammps" with local.cwd(lammps_dir): tests = lammps_dir // "in.*" for test in tests: runner((lammps < wrapping.strip_path_prefix(test, builddir)))
def run_tests(self, experiment, run): exp = wrap(path.join(self.src_dir, "ruby"), experiment) with local.env(RUBYOPT=""): run(ruby[path.join(self.testdir, "benchmark", "run.rb"), "--ruby=\"" + str(exp) + "\"", "--opts=\"-I" + path.join(self.testdir, "lib") + " -I" + path.join(self.testdir, ".") + " -I" + path.join(self.testdir, ".ext", "common") + "\"", "-r"])
def run_tests(self, runner): unpack_dir = local.path('ruby-{0}'.format(self.version)) ruby_n = wrapping.wrap(unpack_dir / "ruby", self) testdir = local.path(self.testdir) with local.env(RUBYOPT=""): run.run(ruby[testdir / "benchmark" / "run.rb", "--ruby=\"" + str(ruby_n) + "\"", "--opts=\"-I" + testdir / "lib" + " -I" + testdir / "." + " -I" + testdir / ".ext" / "common" + "\"", "-r"])
def run_tests(self, runner): src_path = local.path(self.src_file) minisat_lib_path = src_path / "build" / "dynamic" / "lib" testfiles = local.path(self.testdir) // "*.cnf.gz" minisat = wrapping.wrap( src_path / "build" / "dynamic" / "bin" / "minisat", self) for test_f in testfiles: cmd = (minisat.with_env(LD_LIBRARY_PATH=minisat_lib_path) < test_f) runner(cmd, None)
def run_tests(self, runner): wrap(path.join(self.builddir, "usr/bin/x264"), self, self.builddir) x264 = uchroot()["/usr/bin/x264"] tests = [ "--crf 30 -b1 -m1 -r1 --me dia --no-cabac --direct temporal --ssim --no-weightb", "--crf 16 -b2 -m3 -r3 --me hex --no-8x8dct --direct spatial --no-dct-decimate -t0 --slice-max-mbs 50", "--crf 26 -b4 -m5 -r2 --me hex --cqm jvt --nr 100 --psnr --no-mixed-refs --b-adapt 2 --slice-max-size 1500", "--crf 18 -b3 -m9 -r5 --me umh -t1 -A all --b-pyramid normal --direct auto --no-fast-pskip --no-mbtree", "--crf 22 -b3 -m7 -r4 --me esa -t2 -A all --psy-rd 1.0:1.0 --slices 4", "--frames 50 --crf 24 -b3 -m10 -r3 --me tesa -t2", "--frames 50 -q0 -m9 -r2 --me hex -Aall", "--frames 50 -q0 -m2 -r1 --me hex --no-cabac" ] for ifile in self.inputfiles: for _, test in enumerate(tests): uretry(x264[ifile, self.inputfiles[ifile], "--threads", "1", "-o", "/dev/null", test.split(" ")])
def run_tests(self, runner): binary_name = "{name}.benchbuild.serial".format(name=self.name) binary_path = local.path(self.src_file) / "bin" / binary_name exp = wrapping.wrap(binary_path, self) if self.name in self.input_dict: for test_input in self.input_dict[self.name]: input_file = local.path( self.src_file) / "inputs" / self.name / test_input runner(exp["-f", input_file]) else: runner(exp)
def run_tests(self, runner): """ Run the tests of this project. Clients override this method to provide customized run-time tests. Args: experiment: The experiment we run this project under run: A function that takes the run command. """ exp = wrapping.wrap(self.run_f, self) runner(exp)
def run_tests(self, experiment, run): exp = wrap( path.join(self.SRC_FILE, "build", "dynamic", "bin", "minisat"), experiment) testfiles = glob(path.join(self.testdir, "*.cnf.gz")) minisat_lib_path = path.join(self.SRC_FILE, "build", "dynamic", "lib") for test_f in testfiles: with local.env(LD_LIBRARY_PATH=minisat_lib_path + ":" + getenv("LD_LIBRARY_PATH", "")): run((exp < test_f), None)
def run_tests(self, runner): src_path = local.path(self.src_file) lammps_dir = src_path / "src" exp = wrapping.wrap(lammps_dir / "lmp_serial", self) examples_dir = src_path / "examples" tests = examples_dir // "*" // "in.*" for test in tests: dirname = test.dirname with local.cwd(dirname): cmd = (exp < test) runner(cmd, None)
def run_tests(self, runner): """ Execute LevelDB's runtime configuration. Args: experiment: The experiment's run function. """ leveldb = wrapping.wrap( local.path(self.src_file) / "out-static" / "db_bench", self) with local.env(LD_LIBRARY_PATH="{}:{}".format( local.path(self.src_file) / "out-shared", getenv("LD_LIBRARY_PATH", ""))): runner(leveldb)
def run_tests(self, runner): gzip = wrapping.wrap(local.path('/bin/gzip'), self) # Compress runner(gzip["-f", "-k", "--best", "compression/text.html"]) runner(gzip["-f", "-k", "--best", "compression/chicken.jpg"]) runner(gzip["-f", "-k", "--best", "compression/control"]) runner(gzip["-f", "-k", "--best", "compression/input.source"]) runner(gzip["-f", "-k", "--best", "compression/liberty.jpg"]) # Decompress runner(gzip["-f", "-k", "--decompress", "compression/text.html.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/chicken.jpg.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/control.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/input.source.gz"]) runner(gzip["-f", "-k", "--decompress", "compression/liberty.jpg.gz"])
def run_tests(self, runner): bzip2 = wrapping.wrap(local.path(self.src_file) / "bzip2", self) # Compress runner(bzip2["-f", "-z", "-k", "--best", "text.html"]) runner(bzip2["-f", "-z", "-k", "--best", "chicken.jpg"]) runner(bzip2["-f", "-z", "-k", "--best", "control"]) runner(bzip2["-f", "-z", "-k", "--best", "input.source"]) runner(bzip2["-f", "-z", "-k", "--best", "liberty.jpg"]) # Decompress runner(bzip2["-f", "-k", "--decompress", "text.html.bz2"]) runner(bzip2["-f", "-k", "--decompress", "chicken.jpg.bz2"]) runner(bzip2["-f", "-k", "--decompress", "control.bz2"]) runner(bzip2["-f", "-k", "--decompress", "input.source.bz2"]) runner(bzip2["-f", "-k", "--decompress", "liberty.jpg.bz2"])
def run_tests(self, runner): unpack_dir = local.path("gzip-{0}.tar.xz".format(self.version)) gzip = wrapping.wrap(unpack_dir / "gzip", self) # Compress runner(gzip["-f", "-k", "--best", "text.html"]) runner(gzip["-f", "-k", "--best", "chicken.jpg"]) runner(gzip["-f", "-k", "--best", "control"]) runner(gzip["-f", "-k", "--best", "input.source"]) runner(gzip["-f", "-k", "--best", "liberty.jpg"]) # Decompress runner(gzip["-f", "-k", "--decompress", "text.html.gz"]) runner(gzip["-f", "-k", "--decompress", "chicken.jpg.gz"]) runner(gzip["-f", "-k", "--decompress", "control.gz"]) runner(gzip["-f", "-k", "--decompress", "input.source.gz"]) runner(gzip["-f", "-k", "--decompress", "liberty.jpg.gz"])
def run_tests(self, runner): unpack_dir = local.path("CLAPACK-{0}".format(self.version)) with local.cwd(unpack_dir / "BLAS"): xblat2s = wrapping.wrap("xblat2s", self) xblat2d = wrapping.wrap("xblat2d", self) xblat2c = wrapping.wrap("xblat2c", self) xblat2z = wrapping.wrap("xblat2z", self) xblat3s = wrapping.wrap("xblat3s", self) xblat3d = wrapping.wrap("xblat3d", self) xblat3c = wrapping.wrap("xblat3c", self) xblat3z = wrapping.wrap("xblat3z", self) runner((xblat2s < "sblat2.in")) runner((xblat2d < "dblat2.in")) runner((xblat2c < "cblat2.in")) runner((xblat2z < "zblat2.in")) runner((xblat3s < "sblat3.in")) runner((xblat3d < "dblat3.in")) runner((xblat3c < "cblat3.in")) runner((xblat3z < "zblat3.in"))
def run_tests(self, runner): bzip2 = wrapping.wrap(local.path('/bin/bzip2'), self) # Compress runner(bzip2["-f", "-z", "-k", "--best", "compression/text.html"]) runner(bzip2["-f", "-z", "-k", "--best", "compression/chicken.jpg"]) runner(bzip2["-f", "-z", "-k", "--best", "compression/control"]) runner(bzip2["-f", "-z", "-k", "--best", "compression/input.source"]) runner(bzip2["-f", "-z", "-k", "--best", "compression/liberty.jpg"]) # Decompress runner(bzip2["-f", "-k", "--decompress", "compression/text.html.bz2"]) runner( bzip2["-f", "-k", "--decompress", "compression/chicken.jpg.bz2"]) runner(bzip2["-f", "-k", "--decompress", "compression/control.bz2"]) runner( bzip2["-f", "-k", "--decompress", "compression/input.source.bz2"]) runner( bzip2["-f", "-k", "--decompress", "compression/liberty.jpg.bz2"])
def run_tests(self, runner): pg_data = local.path("/test-data/") pg_path = local.path("/usr/bin/postgres") postgres = wrapping.wrap(pg_path, self) def pg_su(command): return su['-c', command, '-g', 'postgres', 'postgres'] dropdb = pg_su('/usr/bin/dropdb') createdb = pg_su("/usr/bin/createdb") pgbench = pg_su("/usr/bin/pgbench") initdb = pg_su("/usr/bin/initdb") pg_server = pg_su(pg_path) with local.env(PGPORT="54329", PGDATA=pg_data): if not pg_data.exists(): runner(initdb) with pg_server.bgrun() as postgres: #We get the PID of the running 'pg_server, which is actually #the PID of the uchroot binary. This is not the PID we #want to send a SIGTERM to. #We need to enumerate all children of 'postgres' recursively #and select the one PID that is named 'postgres.bin' and has #not a process with the same name as parent. #This should be robust enough, as long as postgres doesn't #switch process names after forking. sleep(3) postgres_root = Process(pid=postgres.pid) real_postgres = [ c.pid for c in postgres_root.children(True) if c.name() == 'postgres.bin' and c.parent().name() != 'postgres.bin' ] try: runner(createdb) runner(pgbench["-i", "portage"]) runner(pgbench["-c", 1, "-S", "-t", 1000000, "portage"]) runner(dropdb["portage"]) finally: kill("-sSIGTERM", real_postgres[0])
def run_tests(self, runner): x264 = wrapping.wrap(local.path('/usr/bin/x264'), self) tests = [ "--crf 30 -b1 -m1 -r1 --me dia --no-cabac --direct temporal --ssim --no-weightb", "--crf 16 -b2 -m3 -r3 --me hex --no-8x8dct --direct spatial --no-dct-decimate -t0 --slice-max-mbs 50", "--crf 26 -b4 -m5 -r2 --me hex --cqm jvt --nr 100 --psnr --no-mixed-refs --b-adapt 2 --slice-max-size 1500", "--crf 18 -b3 -m9 -r5 --me umh -t1 -A all --b-pyramid normal --direct auto --no-fast-pskip --no-mbtree", "--crf 22 -b3 -m7 -r4 --me esa -t2 -A all --psy-rd 1.0:1.0 --slices 4", "--frames 50 --crf 24 -b3 -m10 -r3 --me tesa -t2", "--frames 50 -q0 -m9 -r2 --me hex -Aall", "--frames 50 -q0 -m2 -r1 --me hex --no-cabac" ] for ifile in self.inputfiles: for _, test in enumerate(tests): runner(x264[ifile, self.inputfiles[ifile], "--threads", "1", "-o", "/dev/null", test.split(" ")])
def run_tests(self, runner): povray_binary = local.path(self.src_file) / "unix" / self.name tmpdir = local.path("tmp") tmpdir.mkdir() povini = local.path("cfg") / ".povray" / "3.6" / "povray.ini" scene_dir = local.path("share") / "povray-3.6" / "scenes" povray = wrapping.wrap(povray_binary, self) pov_files = find(scene_dir, "-name", "*.pov").splitlines() for pov_f in pov_files: with local.env( POVRAY=povray_binary, INSTALL_DIR='.', OUTPUT_DIR=tmpdir, POVINI=povini): options = ((((head["-n", "50", "\"" + pov_f + "\""] | grep["-E", "'^//[ ]+[-+]{1}[^ -]'"]) | head["-n", "1"]) | sed["s?^//[ ]*??"]) & FG) run.run( povray["+L" + scene_dir, "+L" + tmpdir, "-i" + pov_f, "-o" + tmpdir, options, "-p"], retcode=None)
def test_create(self): with local.cwd(self.tmp_dir): self.cmd = wrappers.wrap(self.tmp_script, EmptyProject(empty.Empty())) self.assertTrue(os.path.exists("{}.bin".format(self.tmp_script))) self.assertTrue(os.path.exists(str(self.cmd)))
def run_tests(self, runner): lulesh = wrapping.wrap("lulesh", self) for i in range(1, 15): runner(lulesh["-i", i])
def run_tests(self, runner): sdcc = wrapping.wrap(self.run_f, self) runner(sdcc)
def run_tests(self, runner): _7z = wrapping.wrap(local.path('/usr/bin/7z'), self) runner(_7z["b", "-mmt1"])
def run_tests(self, runner): scimark2 = wrap(local.path('scimark2'), self) runner(scimark2)
def run_tests(self, runner): exp = wrapping.wrap(self.src_file + ".out", self) runner(exp)
def run_tests(self, runner): """Runs runtime tests for eix""" eix = wrapping.wrap(local.path('/usr/bin/eix'), self) runner(eix["clang"])
def run_tests(self, runner): crafty_path = local.path("/usr/bin/crafty") crafty = wrapping.wrap(crafty_path, self) with open("test1.sh", 'w') as test1: lines = ''' st=10 ponder=off display nomoves setboard rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq move book off setboard rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq move setboard 1k1r4/pp1b1R2/3q2pp/4p3/2B5/4Q3/PPP2B2/2K5 b move setboard 3r1k2/4npp1/1ppr3p/p6P/P2PPPP1/1NR5/5K2/2R5 w move setboard 2q1rr1k/3bbnnp/p2p1pp1/2pPp3/PpP1P1P1/1P2BNNP/2BQ1PRK/7R b move setboard rnbqkb1r/p3pppp/1p6/2ppP3/3N4/2P5/PPP1QPPP/R1B1KB1R w KQkq move setboard r1b2rk1/2q1b1pp/p2ppn2/1p6/3QP3/1BN1B3/PPP3PP/R4RK1 w move setboard 2r3k1/pppR1pp1/4p3/4P1P1/5P2/1P4K1/P1P5/8 w move setboard 1nk1r1r1/pp2n1pp/4p3/q2pPp1N/b1pP1P2/B1P2R2/2P1B1PP/R2Q2K1 w move setboard 4b3/p3kp2/6p1/3pP2p/2pP1P2/4K1P1/P3N2P/8 w move setboard 2kr1bnr/pbpq4/2n1pp2/3p3p/3P1P1B/2N2N1Q/PPP3PP/2KR1B1R w move setboard 3rr1k1/pp3pp1/1qn2np1/8/3p4/PP1R1P2/2P1NQPP/R1B3K1 b move setboard 2r1nrk1/p2q1ppp/bp1p4/n1pPp3/P1P1P3/2PBB1N1/4QPPP/R4RK1 w move setboard r3r1k1/ppqb1ppp/8/4p1NQ/8/2P5/PP3PPP/R3R1K1 b move setboard r2q1rk1/4bppp/p2p4/2pP4/3pP3/3Q4/PP1B1PPP/R3R1K1 w move setboard rnb2r1k/pp2p2p/2pp2p1/q2P1p2/8/1Pb2NP1/PB2PPBP/R2Q1RK1 w move setboard 2r3k1/1p2q1pp/2b1pr2/p1pp4/6Q1/1P1PP1R1/P1PN2PP/5RK1 w move setboard r1bqkb1r/4npp1/p1p4p/1p1pP1B1/8/1B6/PPPN1PPP/R2Q1RK1 w kq move setboard r2q1rk1/1ppnbppp/p2p1nb1/3Pp3/2P1P1P1/2N2N1P/PPB1QP2/R1B2RK1 b move setboard r1bq1rk1/pp2ppbp/2np2p1/2n5/P3PP2/N1P2N2/1PB3PP/R1B1QRK1 b move setboard 3rr3/2pq2pk/p2p1pnp/8/2QBPP2/1P6/P5PP/4RRK1 b move setboard r4k2/pb2bp1r/1p1qp2p/3pNp2/3P1P2/2N3P1/PPP1Q2P/2KRR3 w move setboard 3rn2k/ppb2rpp/2ppqp2/5N2/2P1P3/1P5Q/PB3PPP/3RR1K1 w move setboard 2r2rk1/1bqnbpp1/1p1ppn1p/pP6/N1P1P3/P2B1N1P/1B2QPP1/R2R2K1 b move setboard r1bqk2r/pp2bppp/2p5/3pP3/P2Q1P2/2N1B3/1PP3PP/R4RK1 b kq move setboard r2qnrnk/p2b2b1/1p1p2pp/2pPpp2/1PP1P3/PRNBB3/3QNPPP/5RK1 w move setboard /k/3p/p2P1p/P2P1P///K/ w move setboard /k/rnn////5RBB/K/ w move mt=0 quit EOF ''' test1.write(lines) with open("test2.sh", 'w') as test2: lines = ''' st=10 ponder=off mt=2 setboard 2r2rk1/1bqnbpp1/1p1ppn1p/pP6/N1P1P3/P2B1N1P/1B2QPP1/R2R2K1 b move mt=0 quit ''' test2.write(lines) runner((cat["test1.sh"] | crafty)) runner((cat["test2.sh"] | crafty))
def run_tests(self, runner): unpack_dir = "ffmpeg-{0}".format(self.version) with local.cwd(unpack_dir): wrapping.wrap(self.name, self) runner(make["V=1", "-i", "fate"])