def main() -> None:
    path = download_wiki("en-latest-all-titles-in")

    ensure_dependencies()

    own_sort_exe = find_executable("sort", project_path())
    if own_sort_exe is None:
        warn(f"executable 'sort' not found in {project_path()}")
        sys.exit(1)

    with TemporaryDirectory() as tempdir:
        temp_path = Path(tempdir)
        coreutils_sort = temp_path.joinpath(path.name + ".coreutils-sort")
        own_sort = temp_path.joinpath(path.name + ".own-sort")

        with subtest("Run coreutils sort with 128MB limit"):
            with open(path) as stdin, open(coreutils_sort, "w") as stdout:
                run_with_ulimit("sort", stdin, stdout)

        with subtest("Run own sort with 128MB limit"):
            with open(path) as stdin, open(own_sort, "w") as stdout:
                run_with_ulimit(own_sort_exe, stdin, stdout)

        with subtest("Check if both results matches"):
            run(["cmp", str(coreutils_sort), str(own_sort)])
def main() -> None:
    path = download_wiki("scowiki-latest-all-titles-in")

    ensure_dependencies()

    with TemporaryDirectory() as tempdir:
        temp_path = Path(tempdir)
        coreutils_sort = temp_path.joinpath(path.name + ".coreutils-sort")
        own_sort = temp_path.joinpath(path.name + ".own-sort")

        with subtest("Run coreutils sort..."):
            with open(path) as stdin, open(coreutils_sort, "w") as stdout:
                run(
                    ["sort", "-r"],
                    stdin=stdin,
                    stdout=stdout,
                    extra_env=dict(LC_ALL="C"),
                )

        with subtest("Run own sort..."):
            with open(path) as stdin, open(own_sort, "w") as stdout:
                run_project_executable("sort", ["-r"], stdin=stdin, stdout=stdout)

        with subtest("Check if both results matches"):
            run(["cmp", str(coreutils_sort), str(own_sort)])
Example #3
0
def main() -> None:
    # Run the test program
    test_mutual_exclusion = test_root().joinpath("test_mutual_exclusion")
    if not test_mutual_exclusion.exists():
        run(["make", "-C", str(test_root()), str(test_mutual_exclusion)])

    with subtest("Checking mutual exclusion"):
        run_project_executable(str(test_mutual_exclusion))
def run_with_ulimit(exe: str, stdin: IO[Any], stdout: IO[Any]) -> None:
    # size is in kilobytes
    size = 128 * 1024
    run(
        [f"ulimit -v {quote(str(size))}; {quote(str(exe))}"],
        stdin=stdin,
        stdout=stdout,
        extra_env=dict(LC_ALL="C"),
        shell=True,
    )
Example #5
0
def fuse_check_mnt(tmpdir: str, mnt_path: str) -> None:
    with open(f'{tmpdir}/stdout', 'w+') as stdout:
        run(
            ["mount"],
            stdout=stdout,
        )
    with open(f'{tmpdir}/stdout') as stdin:
        try:
            run(
                ["grep", "memfs"],
                stdin=stdin,
            )
        except Exception as e:
            fuse_unmount(mnt_path)
            sys.exit(1)
    def test_g(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users["andrew"]
        fname = "test_g.txt"

        try:
            os.chdir(andrew["home"])
            fout = open(fname, "w")
            for i in range(10):
                fout.write("line %d\n" % i)
            fout.close()
            p4.add(fname)
            argv = ["px", "-g", "opened", fname]
            output, error, retval = testsupport.run(argv)
            result = eval("".join(output))
            self.failUnless(type(result) == types.DictType)
            opened = p4.opened(fname)[0]
            self.failUnless(result["change"] == opened["change"])
            self.failUnless(result["depotFile"] == opened["depotFile"])
            self.failUnless(result["type"] == opened["type"])
            self.failUnless(int(result["rev"]) == int(opened["rev"]))

            # cleanup
            p4.revert(fname)
        finally:
            os.chdir(top)
    def test_backout_files_already_open(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_backout_files_already_open.txt'

        try:
            os.chdir(andrew['home'])
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            result = p4.submit(fname, 'first checkin of this file')
            self.failUnless(result['action'] == 'submitted')
            cnum = result['change']

            p4.edit(fname)
            argv = ['px', 'backout', str(cnum)]
            output, error, retval = testsupport.run(argv)
            self.failUnless(retval, "This call should have failed but did "\
                                    "not: argv=%s" % argv)

            # Cleanup
            p4.revert(fname)
        finally:
            os.chdir(top)
    def test_added_binary_file(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_added_binary_file.txt'

        try:
            os.chdir(andrew['home'])
            # Make the first revision.
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname, filetype='binary')
            change = p4.submit(fname, "first submission")['change']

            # Generate a patch for the last change.
            argv = ['px', 'genpatch', str(change)]
            output, error, retval = testsupport.run(argv)
            self.failUnless(error[0].startswith('warn:'),
                            "Did not get expected warning for not being "\
                            "able to inline the adde dbinary file.")
            self.failIf(retval)
            patch = ''.join(output)

            # Sync back to before the change, apply the patch, and see
            # if the results are the same as the actual change.
            os.chmod(fname, 0777)
            os.remove(fname)
            self._applyPatch(patch)
            self.failIf(os.path.exists(fname),
                        "Did not expect patch to re-create the binary "\
                        "file: %r" % fname)
        finally:
            os.chdir(top)
    def test_added_file_pending(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_added_file_pending.txt'

        try:
            os.chdir(andrew['home'])
            # Make the first revision.
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)

            # Generate a patch for the default pending changelist.
            argv = ['px', 'genpatch']
            output, error, retval = testsupport.run(argv)
            self.failIf(error, "Unexpected error output: %r" % error)
            self.failIf(retval)
            patch = ''.join(output)

            # Sync back to before the change, apply the patch, and see
            # if the results are the same as the actual change.
            before = open(fname, 'r').read()
            p4.revert(fname)
            os.chmod(fname, 0777)
            os.remove(fname)
            self._applyPatch(patch)
            after = open(fname, 'r').read()
            self.failUnless(before == after,
                            "Applying the generated patch did not work.")
        finally:
            os.chdir(top)
Example #10
0
 def test_PATHEXT_failure(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir
     output, error, retval = testsupport.run(self.which +
                                             ' whichtestapp3')
     self.failUnless(
         retval == 1,
         "'which ...' should have returned 1: retval=%d" % retval)
Example #11
0
 def test_opt_help(self):
     output, error, retval = testsupport.run(self.which + ' --help')
     token = 'Usage:'
     self.failUnless(output.find(token) != -1,
                     "'%s' was not found in 'which --help' output: '%s' "\
                     % (token, output))
     self.failUnless(retval == 0,
                     "'which --help' did not return 0: retval=%d" % retval)
Example #12
0
 def test_opt_help(self):
     output, error, retval = testsupport.run(self.which+' --help')
     token = 'Usage:'.encode('ascii')
     self.failUnless(output.find(token) != -1,
                     "'%s' was not found in 'which --help' output: '%s' "\
                     % (token, output))
     self.failUnless(retval == 0,
                     "'which --help' did not return 0: retval=%d" % retval)
 def test_version(self):
     argv = ["px", "--version"]
     output, error, retval = testsupport.run(argv)
     landmarkRe = re.compile("px \d\.\d\.\d")
     match = landmarkRe.search(output[0])
     self.failUnless(
         match, "Could not find '%s' in first output line " "of %s: %r" % (landmarkRe.pattern, argv, output)
     )
Example #14
0
 def test_exts(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir 
     output, error, retval = testsupport.run(self.which+' -e .wta whichtestapp3')
     expectedOutput = os.path.join(self.tmpdir, "whichtestapp3")
     self.failUnless(self._match(output.strip(), expectedOutput),
         "Output, %r, and expected output, %r, do not match."\
         % (output.strip(), expectedOutput))
     self.failUnless(retval == 0,
         "'which ...' should have returned 0: retval=%d" % retval)
 def test_help(self):
     argv = ["px", "--help"]
     output, error, retval = testsupport.run(argv)
     landmark = "px Options:"
     for line in output:
         if line.strip().startswith(landmark):
             break
     else:
         self.fail("No '%s' line in output of %s." % (landmark, argv))
Example #16
0
 def test_exts(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir
     output, error, retval = testsupport.run(self.which +
                                             ' -e .wta whichtestapp3')
     expectedOutput = os.path.join(self.tmpdir, "whichtestapp3")
     self.failUnless(self._match(output.strip(), expectedOutput),
         "Output, %r, and expected output, %r, do not match."\
         % (output.strip(), expectedOutput))
     self.failUnless(
         retval == 0,
         "'which ...' should have returned 0: retval=%d" % retval)
Example #17
0
 def test_opt_version(self):
     output, error, retval = testsupport.run(self.which+' --version')
     versionRe = re.compile("^which \d+\.\d+\.\d+$".encode('ascii'))
     versionMatch = versionRe.search(output.strip())
     self.failUnless(versionMatch,
                     "Version, '%s', from 'which --version' does not "\
                     "match pattern, '%s'."\
                     % (output.strip(), versionRe.pattern))
     self.failUnless(retval == 0,
                     "'which --version' did not return 0: retval=%d"\
                     % retval)
Example #18
0
 def test_opt_version(self):
     output, error, retval = testsupport.run(self.which + ' --version')
     versionRe = re.compile("^which \d+\.\d+\.\d+$")
     versionMatch = versionRe.search(output.strip())
     self.failUnless(versionMatch,
                     "Version, '%s', from 'which --version' does not "\
                     "match pattern, '%s'."\
                     % (output.strip(), versionRe.pattern))
     self.failUnless(retval == 0,
                     "'which --version' did not return 0: retval=%d"\
                     % retval)
Example #19
0
    def test_same_as_p4_1(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_same_as_p4_1.txt'

        try:
            os.chdir(andrew['home'])
            
            # Make first version of a file.
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            p4.submit(fname, "for test_same_as_p4_1")

            # Make an edit to be able to compare the diffs.
            p4.edit(fname)
            fout = open(fname, 'a')
            fout.write("another line\n")
            fout.close()
            
            pxArgv = ['px', 'diff', '-du', './...']
            pxOutput, pxError, pxRetval = testsupport.run(pxArgv)
            p4Argv = ['p4', 'diff', '-du', './...']
            p4Output, p4Error, p4Retval = testsupport.run(p4Argv)

            self.failUnless(pxOutput == p4Output,
                "Output from running %s was not the same as %s. This %r "\
                "vs this %r." % (pxArgv, p4Argv, pxOutput, p4Output))
            self.failUnless(pxError == p4Error,
                "Error from running %s was not the same as %s. This %r "\
                "vs this %r." % (pxArgv, p4Argv, pxError, p4Error))
            self.failUnless(pxRetval == p4Retval,
                "Retval from running %s was not the same as %s. This %r "\
                "vs this %r." % (pxArgv, p4Argv, pxRetval, p4Retval))

            # cleanup
            p4.revert(fname)
        finally:
            os.chdir(top)
Example #20
0
def main() -> None:
    with tempfile.TemporaryDirectory() as tmpdir:
        temp_path = Path(tmpdir)
        mnt_path  = fuse_mount(temp_path, "memfs_mnt")

        fuse_check_mnt(tmpdir, mnt_path)

        with subtest(""):
            run([os.path.join("tests", "file_io.sh"), "-o", os.path.join(mnt_path, "foo"), "hello"])
            proc = run([os.path.join("tests", "file_io.sh"), "-d", os.path.join(mnt_path, "foo")], stdout=subprocess.PIPE)

            try:
                if proc.stdout != "hello\n":
                    fuse_unmount(mnt_path)
                    print("Written and read data don't match")
                    sys.exit(1)
            except Exception as e:
                fuse_unmount(mnt_path)
                sys.exit(1)
        fuse_unmount(mnt_path)
        sys.exit(0)
Example #21
0
 def test_two_successes(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir 
     apps = ['whichtestapp1', 'whichtestapp2']
     output, error, retval = testsupport.run(
         self.which + ' -q ' + ' '.join(apps))
     lines = output.strip().split("\n".encode('ascii'))
     for app, line in zip(apps, lines):
         expected = os.path.join(self.tmpdir, app)
         self.failUnless(self._match(line, expected),
             "Output, %r, and expected output, %r, do not match."\
             % (line, expected))
     self.failUnless(retval == 0,
         "'which ...' should have returned 0: retval=%d" % retval)
Example #22
0
 def test_two_successes(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir
     apps = ['whichtestapp1', 'whichtestapp2']
     output, error, retval = testsupport.run(self.which + ' -q ' +
                                             ' '.join(apps))
     lines = output.strip().split("\n")
     for app, line in zip(apps, lines):
         expected = os.path.join(self.tmpdir, app)
         self.failUnless(self._match(line, expected),
             "Output, %r, and expected output, %r, do not match."\
             % (line, expected))
     self.failUnless(
         retval == 0,
         "'which ...' should have returned 0: retval=%d" % retval)
    def test_no_newline_at_end_of_file(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_no_newline_at_end_of_file.txt'

        try:
            os.chdir(andrew['home'])
            # Make the first revision.
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            p4.submit(fname, "first submission")

            # Make a second revision (with *no* trailing newline)
            p4.edit(fname)
            fout = open(fname, 'a')
            fout.write("another line")
            fout.close()
            change = p4.submit(fname, "add another line")['change']

            # Generate a patch for the last change.
            argv = ['px', 'genpatch', str(change)]
            output, error, retval = testsupport.run(argv)
            self.failIf(error)
            self.failIf(retval)
            patch = ''.join(output)
            self.failUnless(patch.find("No newline at end of file") != -1)

            # Sync back to before the change, apply the patch, and see
            # if the results are the same as the actual change.
            before = open(fname, 'r').read()
            p4.sync(fname+"#1")
            self._applyPatch(patch)
            after = open(fname, 'r').read()
            if after.endswith('\n'):
                # This is sort of cheating the test, but 'patch' ignores
                # the correctly placed '/ No newline at end of file'
                # that both "diff" and "px genpatch" produce. What are
                # you gonna do?
                after = after[:-1]
            self.failUnless(before == after,
                            "Applying the generated patch did not work.")

        finally:
            os.chdir(top)
    def test_pending(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_pending.txt'

        try:
            os.chdir(andrew['home'])
            # Make the first revision.
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            p4.submit(fname, "first submission")

            # Make a pending change with edits.
            p4.edit(fname)
            fout = open(fname, 'a')
            fout.write("another line\n")
            fout.close()
            change = p4.change(fname, "my pending edits")['change']

            # Generate a patch for the default pending change.
            argv = ['px', 'genpatch', str(change)]
            output, error, retval = testsupport.run(argv)
            self.failIf(error)
            self.failIf(retval)
            patch = ''.join(output)

            # Sync back to before the change, apply the patch, and see
            # if the results are the same as the actual change.
            before = open(fname, 'r').read()
            p4.revert(fname)
            p4.sync(fname+"#1")
            self._applyPatch(patch)
            after = open(fname, 'r').read()
            self.failUnless(before == after,
                            "Applying the generated patch did not work.")
        finally:
            os.chdir(top)
    def test_empty_added_file(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_empty_added_file.txt'

        try:
            os.chdir(andrew['home'])

            # "Add" a file that does not exist.
            p4.add(fname)

            # Generate a patch for the default pending change.
            argv = ['px', 'genpatch', 'default']
            output, error, retval = testsupport.run(argv)
            self.failIf(error, "This command, %r, failed with this error "\
                               "output: %s" % (argv, error))
            self.failIf(retval)
            patch = ''.join(output)
        finally:
            p4.revert(fname)
            os.chdir(top)
    def test_backout_add(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_backout_add.txt'

        try:
            os.chdir(andrew['home'])
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            result = p4.submit(fname, 'first checkin of this file')
            self.failUnless(result['action'] == 'submitted')
            cnum = result['change']
            argv = ['px', 'backout', str(cnum)]
            output, error, retval = testsupport.run(argv)

            lineRe = re.compile('^Change (\d+) created to backout change '\
                                '(\d+)\.$')
            match = lineRe.match(output[0])
            self.failUnless(match, "Unknown 'px backout' first output "\
                                   "line: '%s'." % output[0])
            self.failUnless(int(match.group(2)) == cnum)
            pendingCnum = int(match.group(1))
            c = p4.change(change=pendingCnum)
            self.failUnless(c['description'].startswith("Backout change"))
            self.failUnless(len(c['files']) == 1)
            self.failUnless(c['files'][0]['action'] == 'delete')
            self.failUnless(c['files'][0]['depotFile']
                            == p4.where(fname)[0]['depotFile'])

            # cleanup
            p4.change([], change=pendingCnum)
            p4.change(change=pendingCnum, delete=1)
            p4.revert(fname)
        finally:
            os.chdir(top)
Example #27
0
def _testOneInputFile(self, fname):
    import preprocess
    DEBUG = False # Set to true to dump status info for each test run.

    # Determine input options to use, if any.
    optsfile = os.path.join('inputs', fname+'.opts') # input options
    opts = []
    if os.path.exists(optsfile):
        for line in open(optsfile, 'r').readlines():
            if line[-1] == "\n": line = line[:-1]
            opts.append(line.strip())
        #print "options from '%s': %s" % (optsfile, pprint.pformat(opts))

    # Preprocess.
    infile = os.path.join('inputs', fname) # input
    outfile = os.path.join('tmp', fname) # actual output
    preprocess_py = join(dirname(dirname(abspath(__file__))), "lib", "preprocess.py")
    argv = [sys.executable, preprocess_py] + opts + ["-o", outfile, infile]
    dummy, err, retval = testsupport.run(argv)
    try:
        out = open(outfile, 'r').read()
    except IOError, ex:
        self.fail("unexpected error running '%s': '%s' was not generated:\n"
                  "\t%s" % (' '.join(argv), outfile, err))
Example #28
0
    def test_list_new_files(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fname = 'test_list_new_files.txt'

        try:
            os.chdir(andrew['home'])
            fout = open(fname, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            p4.add(fname)
            argv = ['px', 'diff', '-sn', './...']
            output, error, retval = testsupport.run(argv)

            files = [f[:-1] for f in output] # drop newlines
            self.failUnless(os.path.abspath(fname) in files)
            self.failIf(error)
            self.failIf(retval)

            # cleanup
            p4.revert(fname)
        finally:
            os.chdir(top)
Example #29
0
 def test_no_args(self):
     output, error, retval = testsupport.run(self.which)
     self.failUnless(retval == -1,
                     "'which' with no args should return -1: retval=%d"\
                     % retval)
Example #30
0
 def test_one_failure(self):
     output, error, retval = testsupport.run(
         self.which+' whichtestapp1')
     self.failUnless(retval == 1,
         "One failure did not return 1: retval=%d" % retval)
def _testOneInputFile(self, fname):
    import preprocess
    DEBUG = False  # Set to true to dump status info for each test run.

    # Determine input options to use, if any.
    optsfile = os.path.join('inputs', fname + '.opts')  # input options
    opts = []
    if os.path.exists(optsfile):
        for line in open(optsfile, 'r').readlines():
            if line[-1] == "\n": line = line[:-1]
            opts.append(line.strip())
        #print "options from '%s': %s" % (optsfile, pprint.pformat(opts))

    # Preprocess.
    infile = os.path.join('inputs', fname)  # input
    outfile = os.path.join('tmp', fname)  # actual output
    preprocess_py = join(dirname(dirname(abspath(__file__))), "lib",
                         "preprocess.py")
    argv = [sys.executable, preprocess_py] + opts + ["-o", outfile, infile]
    dummy, err, retval = testsupport.run(argv)
    try:
        out = open(outfile, 'r').read()
    except IOError as ex:
        self.fail("unexpected error running '%s': '%s' was not generated:\n"
                  "\t%s" % (' '.join(argv), outfile, err))
    if DEBUG:
        print()
        print("*" * 50, "cmd")
        print(' '.join(argv))
        print("*" * 50, "stdout")
        print(out)
        print("*" * 50, "stderr")
        print(err)
        print("*" * 50, "retval")
        print(str(retval))
        print("*" * 50)

    # Compare results with the expected.
    expoutfile = os.path.join('outputs', fname)  # expected stdout output
    experrfile = os.path.join('outputs',
                              fname + '.err')  # expected error output
    if os.path.exists(expoutfile):
        expout = open(expoutfile, 'r').read()
        #print "expected stdout output: %r" % expout
        if not sys.platform.startswith("win"):
            expout = expout.replace('\\', '/')  # use Un*x paths
        if expout != out:
            diff = list(difflib.ndiff(expout.splitlines(1), out.splitlines(1)))
            self.fail("%r != %r:\n%s"\
                      % (expoutfile, outfile, pprint.pformat(diff)))
    if os.path.exists(experrfile):
        experr = open(experrfile, 'r').read()
        #print "expected stderr output: %r" % experr
        massaged_experr = experr.replace("inputs/", "inputs" + os.sep)
        diff = list(
            difflib.ndiff(massaged_experr.strip().splitlines(1),
                          err.strip().splitlines(1)))
        self.assertEqual(massaged_experr.strip(), err.strip(),
                             "<expected error> != <actual error>:\n%s"\
                             % pprint.pformat(diff))
    elif err:
        self.fail("there was error output when processing '%s', but no "\
                  "expected stderr output file, '%s'" % (infile, experrfile))

    # Ensure next test file gets a clean preprocess.
    del sys.modules['preprocess']
Example #32
0
def fuse_unmount(mnt_path: str) -> "subprocess.CompletedProcess[Text]":
    if os.path.isdir(mnt_path):
        if os.path.ismount(mnt_path):
            run(["fusermount", "-u", str(mnt_path)])
Example #33
0
 def test_PATHEXT_failure(self):
     os.environ["PATH"] += os.pathsep + self.tmpdir 
     output, error, retval = testsupport.run(self.which+' whichtestapp3')
     self.failUnless(retval == 1,
         "'which ...' should have returned 1: retval=%d" % retval)
def main() -> None:
    # Run the test program
    test_lock_hashmap = test_root().joinpath("lockfree_hashmap")
    if not test_lock_hashmap.exists():
        run(["make", "-C", str(test_root()), str(test_lock_hashmap)])
    times = []
    with tempfile.TemporaryDirectory() as tmpdir:
        with subtest("Checking correctness"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                run_project_executable(
                    str(test_lock_hashmap),
                    args=[
                        "-d20000", "-i10000", "-n4", "-r10000", "-u100", "-b1"
                    ],
                    stdout=stdout,
                )
                output = open(f"{tmpdir}/stdout").readlines()
                sanity_check(output[1:], 1, 10000, 4)
        with subtest("Checking 1 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d20000", "-i10000", "-n1", "-r10000", "-u10",
                            "-b1"
                        ],
                        stdout=stdout,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 1, 10000, 1)
                times.append(runtime / 3)
        with subtest("Checking 2 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d20000", "-i10000", "-n2", "-r10000", "-u10",
                            "-b1"
                        ],
                        stdout=stdout,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 1, 10000, 2)
                times.append(runtime / 3)
        with subtest("Checking 4 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d20000", "-i10000", "-n4", "-r10000", "-u10",
                            "-b1"
                        ],
                        stdout=stdout,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 1, 10000, 4)
                times.append(runtime / 3)

        f1 = times[0] / times[1]
        f2 = times[1] / times[2]
        if f1 < 1.4 or f2 < 1.4:
            warn("Hashmap is not scaling properly: " + str(times))
            exit(1)

        with subtest("Checking if hashmap cleans up items when removing"):
            test_cleanup_lockfree = test_root().joinpath(
                "test_cleanup_lockfree")

            if not test_cleanup_lockfree.exists():
                run([
                    "make", "-C",
                    str(test_root()),
                    str(test_cleanup_lockfree)
                ])

            with open(f"{tmpdir}/stdout", "w+") as stdout:
                run_project_executable(str(test_cleanup_lockfree),
                                       stdout=stdout)

                stdout.seek(0)
                lines = stdout.readlines()
                first = float(lines[0])
                second = float(lines[1])

                if second / first > 1.5:
                    warn(
                        f"Hashmap does not cleanup properly when removing items: {first}, {second}"
                    )
                    exit(1)
Example #35
0
 def test_two_failures(self):
     output, error, retval = testsupport.run(
         self.which+' whichtestapp1 whichtestapp2')
     self.failUnless(retval == 2,
         "Two failures did not return 2: retval=%d" % retval)
Example #36
0
 def test_one_failure(self):
     output, error, retval = testsupport.run(self.which + ' whichtestapp1')
     self.failUnless(retval == 1,
                     "One failure did not return 1: retval=%d" % retval)
    def test_backout_addeditdelete(self):
        p4 = P4()
        top = os.getcwd()
        andrew = testsupport.users['andrew']
        fnameAdd = 'test_backout_addeditdelete_add.txt'
        fnameEdit = 'test_backout_addeditdelete_edit.txt'
        fnameDelete = 'test_backout_addeditdelete_delete.txt'

        try:
            os.chdir(andrew['home'])
            # Make this change:
            #   ... //depot/foo#1 add
            #   ... //depot/bar#3 delete
            #   ... //depot/ola#4 edit
            fout = open(fnameEdit, 'w')
            for i in range(10): fout.write('line %d\n' % i)
            fout.close()
            fout = open(fnameDelete, 'w')
            fout.write("Hello from the add file.")
            fout.close()
            p4.add([fnameEdit, fnameDelete])
            p4.submit([fnameEdit, fnameDelete],
                      'setup for test_backout_addeditdelete')

            p4.delete(fnameDelete)
            p4.edit(fnameEdit)
            contents = open(fnameEdit, 'r').readlines()
            contents[0] = contents[0][:-1] + " (hello again)\n"
            fout = open(fnameEdit, 'w')
            fout.write(''.join(contents))
            fout.close()
            fout = open(fnameAdd, 'w')
            fout.write("Hello from the add file.")
            fout.close()
            p4.add(fnameAdd)
            result = p4.submit([fnameAdd, fnameEdit, fnameDelete],
                               'test submission to backout')
            cnum = result['change']

            argv = ['px', 'backout', str(cnum)]
            output, error, retval = testsupport.run(argv)

            lineRe = re.compile('^Change (\d+) created to backout change '\
                                '(\d+)\.$')
            match = lineRe.match(output[0])
            self.failUnless(match, "Unknown 'px backout' first output "\
                                   "line: '%s'." % output[0])
            self.failUnless(int(match.group(2)) == cnum)
            pendingCnum = int(match.group(1))
            c = p4.change(change=pendingCnum)
            self.failUnless(c['description'].startswith("Backout change"))
            self.failUnless(len(c['files']) == 3)
            for file in c['files']:
                localFile = p4.where(file['depotFile'])[0]['localFile']
                basename = os.path.basename(localFile)
                if basename == fnameAdd:
                    self.failUnless(file['action'] == 'delete')
                if basename == fnameDelete:
                    self.failUnless(file['action'] == 'add')
                if basename == fnameEdit:
                    self.failUnless(file['action'] == 'edit')

            # cleanup
            p4.change([], change=pendingCnum)
            p4.change(change=pendingCnum, delete=1)
            p4.revert([fnameAdd, fnameDelete, fnameEdit])
        finally:
            os.chdir(top)
Example #38
0
 def test_two_failures(self):
     output, error, retval = testsupport.run(self.which +
                                             ' whichtestapp1 whichtestapp2')
     self.failUnless(retval == 2,
                     "Two failures did not return 2: retval=%d" % retval)
Example #39
0
 def test_no_args(self):
     output, error, retval = testsupport.run(self.which)
     self.failUnless(retval == -1,
                     "'which' with no args should return -1: retval=%d"\
                     % retval)
Example #40
0
def main() -> None:
    # Run the test program
    lib = ensure_library("liblockhashmap.so")
    extra_env = {"LD_LIBRARY_PATH": str(os.path.dirname(lib))}
    test_lock_hashmap = test_root().joinpath("lock_hashmap")
    if not test_lock_hashmap.exists():
        run(["make", "-C", str(test_root()), str(test_lock_hashmap)])
    times = []
    with tempfile.TemporaryDirectory() as tmpdir:
        with open(f"{tmpdir}/stdout", "w+") as stdout:
            run_project_executable(
                str(test_lock_hashmap),
                args=["-d20000", "-i10000", "-n4", "-r10000", "-u100", "-b1"],
                stdout=stdout,
                extra_env=extra_env,
            )
            output = open(f"{tmpdir}/stdout").readlines()
            sanity_check(output[1:], 1, 10000, 4)
        with subtest("Checking 1 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d2000000", "-i100000", "-n1", "-r100000", "-u10"
                        ],
                        stdout=stdout,
                        extra_env=extra_env,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 512, 100000, 1)
                times.append(runtime / 3)
        with subtest("Checking 2 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d2000000", "-i100000", "-n2", "-r100000", "-u10"
                        ],
                        stdout=stdout,
                        extra_env=extra_env,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 512, 100000, 2)
                times.append(runtime / 3)
        with subtest("Checking 4 thread time"):
            with open(f"{tmpdir}/stdout", "w+") as stdout:
                runtime = 0.0
                for i in range(0, 3):
                    run_project_executable(
                        str(test_lock_hashmap),
                        args=[
                            "-d2000000", "-i100000", "-n4", "-r100000", "-u10"
                        ],
                        stdout=stdout,
                        extra_env=extra_env,
                    )
                    output = open(f"{tmpdir}/stdout").readlines()
                    runtime += float(output[0].strip())
                    sanity_check(output[1:], 512, 100000, 4)
                times.append(runtime / 3)

        f1 = times[0] / times[1]
        f2 = times[1] / times[2]
        if f1 < 1.4 or f2 < 1.4:
            warn("Hashmap is not scaling properly: " + str(times))
            exit(1)