view contrib/bdiff-torture.py @ 41181:3227923979a1

tests: de-flake test-narrow-share.t by making dirstate predictable

test-narrow-share.t was sometimes (~0.5% on my machine) failing like this:

  @@ -61,7 +61,7 @@
     A d3/g
     $ hg -R main debugdirstate --no-dates
     n 644          2 set                 d1/f
  -  n 644          2 unset               d3/f
  +  n 644          2 set                 d3/f
     a   0         -1 unset               d3/g
     n 644          2 set                 d5/f
     n 644          2 set                 d7/f

The timestamp for d3/f would get set if it was determined at some
point that it was clean. That check is usually done when the user runs
`hg st`. We don't do that before the failure in the test case, but it
happens at the end of the `hg clone` call. So if the file system's
time happens to roll over after the clone's working copy has been
written, but before its (final) dirstate has been written, we can end
up with a set timestamp there.

This patch makes it consistent by sleeping for 2 seconds so the
timestamp gets reliably set.

Differential Revision: https://phab.mercurial-scm.org/D5568

# Randomized torture test generation for bdiff

from __future__ import absolute_import, print_function
import random
import sys

from mercurial import (
    mdiff,
)

def reducetest(a, b):
    tries = 0
    reductions = 0
    print("reducing...")
    while tries < 1000:
        a2 = "\n".join(l for l in a.splitlines()
                       if random.randint(0, 100) > 0) + "\n"
        b2 = "\n".join(l for l in b.splitlines()
                       if random.randint(0, 100) > 0) + "\n"
        if a2 == a and b2 == b:
            continue
        if a2 == b2:
            continue
        tries += 1

        try:
            test1(a, b)
        except Exception as inst:
            reductions += 1
            tries = 0
            a = a2
            b = b2

    print("reduced:", reductions, len(a) + len(b),
          repr(a), repr(b))
    try:
        test1(a, b)
    except Exception as inst:
        print("failed:", inst)

    sys.exit(0)

def test1(a, b):
    d = mdiff.textdiff(a, b)
    if not d:
        raise ValueError("empty")
    c = mdiff.patches(a, [d])
    if c != b:
        raise ValueError("bad")

def testwrap(a, b):
    try:
        test1(a, b)
        return
    except Exception as inst:
        pass
    print("exception:", inst)
    reducetest(a, b)

def test(a, b):
    testwrap(a, b)
    testwrap(b, a)

def rndtest(size, noise):
    a = []
    src = "                aaaaaaaabbbbccd"
    for x in xrange(size):
        a.append(src[random.randint(0, len(src) - 1)])

    while True:
        b = [c for c in a if random.randint(0, 99) > noise]
        b2 = []
        for c in b:
            b2.append(c)
            while random.randint(0, 99) < noise:
                b2.append(src[random.randint(0, len(src) - 1)])
        if b2 != a:
            break

    a = "\n".join(a) + "\n"
    b = "\n".join(b2) + "\n"

    test(a, b)

maxvol = 10000
startsize = 2
while True:
    size = startsize
    count = 0
    while size < maxvol:
        print(size)
        volume = 0
        while volume < maxvol:
            rndtest(size, 2)
            volume += size
            count += 2
        size *= 2
    maxvol *= 4
    startsize *= 4