diff --git a/bin-for-dist/all-plat.sh b/bin-for-dist/all-plat.sh
deleted file mode 100755
index 7916bf61f..000000000
--- a/bin-for-dist/all-plat.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-
-        
-py.test --dist=each $* \
-    --tx 'socket=192.168.1.106:8888'
-    #--tx 'popen//python=python2.6' \
-    #--tx 'ssh=noco//python=/usr/local/bin/python2.4//chdir=/tmp/pytest-python2.4' \
diff --git a/bin-for-dist/findmissingdocstrings.py b/bin-for-dist/findmissingdocstrings.py
deleted file mode 100755
index c354de61e..000000000
--- a/bin-for-dist/findmissingdocstrings.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env python
-
-import py
-import inspect
-import types
-
-def report_strange_docstring(name, obj):
-    if obj.__doc__ is None:
-        print "%s misses a docstring" % (name, )
-    elif obj.__doc__ == "":
-        print "%s has an empty" % (name, )
-    elif "XXX" in obj.__doc__:
-        print "%s has an 'XXX' in its docstring" % (name, )
-
-def find_code(method):
-    return getattr(getattr(method, "im_func", None), "func_code", None)
-
-def report_different_parameter_names(name, cls):
-    bases = cls.__mro__
-    for base in bases:
-        for attr in dir(base):
-            meth1 = getattr(base, attr)
-            code1 = find_code(meth1)
-            if code1 is None:
-                continue
-            if not callable(meth1):
-                continue
-            if not hasattr(cls, attr):
-                continue
-            meth2 = getattr(cls, attr)
-            code2 = find_code(meth2)
-            if not callable(meth2):
-                continue
-            if code2 is None:
-                continue
-            args1 = inspect.getargs(code1)[0]
-            args2 = inspect.getargs(code2)[0]
-            for a1, a2 in zip(args1, args2):
-                if a1 != a2:
-                    print "%s.%s have different argument names %s, %s than the version in %s" % (name, attr, a1, a2, base)
-
-
-def find_all_exported():
-    stack = [(name, getattr(py, name)) for name in dir(py)[::-1]
-             if not name.startswith("_") and name != "compat"]
-    seen = {}
-    exported = []
-    while stack:
-        name, obj = stack.pop()
-        if id(obj) in seen:
-            continue
-        else:
-            seen[id(obj)] = True
-        exported.append((name, obj))
-        if isinstance(obj, type) or isinstance(obj, type(py)):
-            stack.extend([("%s.%s" % (name, s), getattr(obj, s)) for s in dir(obj)
-                           if len(s) <= 1 or not (s[0] == '_' and s[1] != '_')])
-    return exported
-
-
-
-if __name__ == '__main__':
-    all_exported = find_all_exported()
-    print "strange docstrings"
-    print "=================="
-    print
-    for name, obj in all_exported:
-        if callable(obj):
-            report_strange_docstring(name, obj)
-    print "\n\ndifferent parameters"
-    print     "===================="
-    print
-    for name, obj in all_exported:
-        if isinstance(obj, type):
-            report_different_parameter_names(name, obj)
-
diff --git a/bin-for-dist/gendoc.py b/bin-for-dist/gendoc.py
deleted file mode 100755
index e5c69865e..000000000
--- a/bin-for-dist/gendoc.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-XXX
-
-import sys
-import os
-from _findpy import py
-try:
-    import apigen
-except ImportError:
-    print 'Can not find apigen - make sure PYTHONPATH is set correctly!'
-    py.std.sys.exit()
-else:
-    args = list(sys.argv[1:])
-    args.extend(['-p', 'apigen'])
-    argkeys = [a.split('=')[0] for a in args]
-    if '--apigen' not in argkeys:
-        args.append('--apigen')
-    if '--apigenscript' not in argkeys:
-        fpath = os.path.join(
-            os.path.dirname(apigen.__file__), 'tool', 'py_build', 'build.py')
-        args.append('--apigenscript=%s' % (fpath,))
-    if '--apigenpath' not in argkeys:
-        args.append('--apigenpath=api')
-    py.test.cmdline.main(args)
diff --git a/bin-for-dist/genscripts.py b/bin-for-dist/genscripts.py
deleted file mode 100644
index b86d69029..000000000
--- a/bin-for-dist/genscripts.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import py
-
-bindir = py.path.local(__file__).dirpath().dirpath("bin")
-assert bindir.check(), bindir
-
-def getbasename(name):
-    assert name[:2] == "py"
-    return "py." + name[2:]
-
-def genscript_unix(name):
-    basename = getbasename(name)
-    path = bindir.join(basename)
-    path.write(py.code.Source("""
-        #!/usr/bin/env python
-        from _findpy import py
-        py.cmdline.%s()
-    """ % name).strip())
-    path.chmod(0755)
-
-def genscript_windows(name):
-    basename = getbasename(name)
-    winbasename = basename + ".cmd"
-    path = bindir.join("win32").join(winbasename)
-    path.write(py.code.Source("""
-         @echo off
-         python "%%~dp0\..\%s" %%*
-    """ % (basename)).strip())
-
-if __name__ == "__main__":
-    for name in dir(py.cmdline):
-        if name[0] != "_":
-            genscript_unix(name)
-            genscript_windows(name)
diff --git a/bin-for-dist/gensetup.py b/bin-for-dist/gensetup.py
deleted file mode 100644
index ffc0b3c69..000000000
--- a/bin-for-dist/gensetup.py
+++ /dev/null
@@ -1,315 +0,0 @@
-import sys
-
-sys.path.insert(0, sys.argv[1])
-import py
-
-toolpath = py.path.local(__file__)
-binpath = py.path.local(py.__file__).dirpath('bin')
-
-def error(msg):
-    print >>sys.stderr, msg
-    raise SystemExit, 1
-
-def reformat(text):
-    return " ".join(text.split())
-
-class SetupWriter(object):
-    EXCLUDES = ("MANIFEST.in", "contrib")
-
-    def __init__(self, basedir, pkg, setuptools=False):
-        self.basedir = basedir
-        self.setuptools = setuptools
-        assert self.basedir.check()
-        self.pkg = pkg
-        self.meta = pkg.__pkg__
-        self.lines = []
-        self.allpaths = self.getallpath(self.basedir)
-
-    def getallpath(self, basedir):
-        contrib = self.basedir.join("contrib")
-        allpath = []
-        lines = py.process.cmdexec("hg st -mcan").split("\n")
-        for path in lines:
-            p = basedir.join(path)
-            assert p.check(), p
-            if not p.relto(contrib) and p != contrib and not self.isexcluded(p):
-                allpath.append(p)
-        return allpath
-
-    def append(self, string):
-        lines = string.split("\n")
-        while lines:
-            if not lines[0].strip():
-                lines.pop(0)
-                continue
-            break
-        if not lines:
-            self.lines.append("")
-            return
-        line = lines[0]
-        indent = len(line) - len(line.lstrip())
-        for line in lines:
-            if line.strip():
-                assert not line[:indent].strip(), line
-                line = line[indent:]
-            self.lines.append(line)
-
-    def write_winfuncs(self):
-        self.append('''
-        ''')
-
-    def tip_info(self, indent=8):
-        old = self.basedir.chdir()
-        indent = " " * indent
-        try:
-            info = []
-            output = py.process.cmdexec(
-                "hg tip --template '" # tags: {tags}\n"
-                #"branch: {branches}\n"
-                "revision: {rev}:{node}\n'"
-            )
-            for line in output.split("\n"):
-                info.append("%s %s" %(indent, line.strip()))
-            return "\n".join(info)
-        finally:
-            old.chdir()
-
-    def setup_header(self):
-        #tooltime = "%s %s" %(py.std.time.asctime(), py.std.time.tzname[0])
-        toolname = toolpath.basename
-        #toolrevision = py.path.svnwc(toolpath).info().rev
-
-        pkgname = self.pkg.__name__
-        self.append('"""py lib / py.test setup.py file"""')
-        self.append('import os, sys')
-        self.append("from setuptools import setup")
-
-    def setup_trailer(self):
-        self.append('''
-            if __name__ == '__main__':
-                main()
-        ''')
-
-    def setup_function(self):
-        params = self.__dict__.copy()
-        params.update(self.meta.__dict__)
-        self.append('long_description = """')
-        for line in params['long_description'].split('\n'):
-            self.append(line)
-        self.append('"""')
-        trunk = None
-        if params['version'] == 'trunk':
-            trunk = 'trunk'
-        self.append('trunk = %r' % trunk)
-        self.append('''
-            def main():
-                setup(
-                    name=%(name)r,
-                    description=%(description)r,
-                    long_description = long_description,
-                    version= trunk or %(version)r,
-                    url=%(url)r,
-                    license=%(license)r,
-                    platforms=%(platforms)r,
-                    author=%(author)r,
-                    author_email=%(author_email)r,
-        ''' % params)
-        indent = " " * 8
-        self.append_pprint(indent, entry_points={'console_scripts':self.getconsolescripts()})
-        self.append_pprint(indent, classifiers=self.meta.classifiers)
-        self.append_pprint(indent, packages=self.getpackages())
-        self.append_pprint(indent, package_data=self.getpackagedata())
-        self.append_pprint(indent, zip_safe=True)
-        self.append_pprint(indent, install_requires=['apipkg'])
-        self.lines.append(indent[4:] + ")\n")
-
-    def setup_scripts(self):
-        # XXX this was used for a different approach
-        not used
-        self.append("""
-            def getscripts():
-                if sys.platform == "win32":
-                    base = "py/bin/win32/"
-                    ext = ".cmd"
-                else:
-                    base = "py/bin/"
-                    ext = ""
-                l = []
-                for name in %r:
-                    l.append(base + name + ext)
-                return l
-        """ % ([script.basename for script in binpath.listdir("py.*")]))
-
-    def append_pprint(self, indent, append=",", **kw):
-        for name, value in kw.items():
-            stringio = py.std.StringIO.StringIO()
-            value = py.std.pprint.pprint(value, stream=stringio)
-            stringio.seek(0)
-            lines =  stringio.readlines()
-            line = lines.pop(0).rstrip()
-            self.lines.append(indent + "%s=%s" %(name, line))
-            indent = indent + " " * (len(name)+1)
-            for line in lines:
-                self.lines.append(indent + line.rstrip())
-            self.lines[-1] = self.lines[-1] + append
-
-    def getconsolescripts(self):
-        bindir = self.basedir.join('py', 'bin')
-        scripts = []
-        for p in self.allpaths:
-            if p.dirpath() == bindir:
-                if p.basename.startswith('py.'):
-                    shortname = "py" + p.basename[3:]
-                    scripts.append("%s = py.cmdline:%s" %
-                        (p.basename, shortname))
-        return scripts
-
-    def getscripts(self):
-        bindir = self.basedir.join('py', 'bin')
-        scripts = []
-        for p in self.allpaths:
-            if p.dirpath() == bindir:
-                if p.basename.startswith('py.'):
-                    scripts.append(p.relto(self.basedir))
-        return scripts
-
-    def getpackages(self):
-        packages = []
-        for p in self.allpaths: # contains no directories!
-            #if p.basename == "py":
-            #    continue
-            if p.dirpath('__init__.py').check():
-                modpath = p.dirpath().relto(self.basedir).replace(p.sep, '.')
-                if modpath != "py" and not modpath.startswith("py."):
-                    continue
-                if modpath in packages:
-                    continue
-                for exclude in self.EXCLUDES:
-                    if modpath.startswith(exclude):
-                        print "EXCLUDING", modpath
-                        break
-                else:
-                    packages.append(modpath)
-        packages.sort()
-        return packages
-
-    def getpackagedata(self):
-        datafiles = []
-        pkgbase = self.basedir.join(self.pkg.__name__)
-        for p in self.allpaths:
-            if p.check(file=1) and (not p.dirpath("__init__.py").check()
-               or p.ext != ".py"):
-                if p.dirpath() != self.basedir:
-                    x = p.relto(pkgbase)
-                    if x:
-                        datafiles.append(p.relto(pkgbase))
-        return {'py': datafiles}
-
-    def getdatafiles(self):
-        datafiles = []
-        for p in self.allpaths:
-            if p.check(file=1) and not p.ext == ".py":
-                if p.dirpath() != self.basedir:
-                    datafiles.append(p.relto(self.basedir))
-        return datafiles
-
-    def setup_win32(self):
-        import winpath
-        self.append(py.std.inspect.getsource(winpath))
-        self.append("""
-            from distutils.command.install import install
-            class my_install(install):
-                def finalize_other(self):
-                    install.finalize_other(self)
-                    on_win32_add_to_PATH()
-            cmdclass = {'install': my_install}
-        """)
-
-    def setup_win32(self):
-        self.append(r'''
-        # scripts for windows: turn "py.SCRIPT" into "py_SCRIPT" and create
-        # "py.SCRIPT.cmd" files invoking "py_SCRIPT"
-        from distutils.command.install_scripts import install_scripts
-        class my_install_scripts(install_scripts):
-            def run(self):
-                install_scripts.run(self)
-                #print self.outfiles
-                for fn in self.outfiles:
-                    basename = os.path.basename(fn)
-                    if basename.startswith("py.") and not basename.endswith(".cmd"):
-                        newbasename = basename.replace(".", "_")
-                        newfn = os.path.join(os.path.dirname(fn), newbasename)
-                        if os.path.exists(newfn):
-                            os.remove(newfn)
-                        os.rename(fn, newfn)
-                        fncmd = fn + ".cmd"
-                        if os.path.exists(fncmd):
-                           os.remove(fncmd)
-                        f = open(fncmd, 'w')
-                        f.write("@echo off\n")
-                        f.write('python "%%~dp0\%s" %%*' %(newbasename))
-                        f.close()
-        if sys.platform == "win32":
-            cmdclass = {'install_scripts': my_install_scripts}
-        else:
-            cmdclass = {}
-        ''')
-
-    def write_setup(self):
-        self.setup_header()
-        self.setup_function()
-        #self.setup_scripts()
-        #self.setup_win32()
-        self.setup_trailer()
-        targetfile = self.basedir.join("setup.py")
-        targetfile.write("\n".join(self.lines))
-        print "wrote",  targetfile
-
-    def isexcluded(self, wcpath):
-        return wcpath.basename[0] == "."
-        rel = wcpath.relto(self.basedir)
-        if rel.find("testing") != -1:
-            return True
-
-    def write_manifest(self):
-        lines = []
-        for p in self.allpaths:
-            if p.check(dir=1):
-                continue
-            toadd = p.relto(self.basedir)
-            if toadd:
-                for exclude in self.EXCLUDES:
-                    if toadd.startswith(exclude):
-                        break
-                    assert toadd.find(exclude) == -1, (toadd, exclude)
-                else:
-                    lines.append("%s" %(toadd))
-        lines.sort()
-        targetfile = self.basedir.join("MANIFEST")
-        targetfile.write("\n".join(lines))
-        print "wrote",  targetfile
-
-    def write_all(self):
-        #self.write_manifest()
-        self.write_setup()
-
-def parseargs():
-    basedir = py.path.local(sys.argv[1])
-    if not basedir.check():
-        error("basedir not found: %s" %(basedir,))
-    pydir = basedir.join('py')
-    if not pydir.check():
-        error("no 'py' directory found in: %s" %(pydir,))
-    actualpydir = py.path.local(py.__file__).dirpath()
-    if pydir != actualpydir:
-        error("package dir conflict, %s != %s" %(pydir, actualpydir))
-    return basedir
-
-def main(basedir=None):
-    if basedir is None:
-        basedir = parseargs()
-    writer = SetupWriter(basedir, py, setuptools=True)
-    writer.write_all()
-
-if __name__ == "__main__":
-    main()
diff --git a/bin-for-dist/hudson.py b/bin-for-dist/hudson.py
deleted file mode 100644
index ba526ffe6..000000000
--- a/bin-for-dist/hudson.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import os, sys, subprocess, urllib
-
-BUILDNAME=os.environ.get('BUILD_NUMBER', "1")
-
-def call(*args):
-    ret = subprocess.call(list(args))
-    assert ret == 0
-
-def bincall(*args):
-    args = list(args)
-    args[0] = os.path.join(BIN, args[0])
-    call(*args)
-
-call("virtualenv", os.path.abspath(BUILDNAME), '--no-site-packages')
-BIN=os.path.abspath(os.path.join(BUILDNAME, 'bin'))
-if not os.path.exists(BIN):
-    BIN=os.path.abspath(os.path.join(BUILDNAME, 'Scripts'))
-    assert os.path.exists(BIN)
-
-PYTHON=os.path.join(BIN, 'python')
-bincall("python", "setup.py", "develop", "-q")
-bincall("pip", "install", "-r", "testing/pip-reqs1.txt",
-               "-q", "--download-cache=download")
-bincall("py.test", "--ignore", BUILDNAME,
-        "--xml=junit.xml",
-        "--report=skipped", "--runslowtest", *sys.argv[1:])
diff --git a/bin-for-dist/makepluginlist.py b/bin-for-dist/makepluginlist.py
deleted file mode 100644
index d2362b21f..000000000
--- a/bin-for-dist/makepluginlist.py
+++ /dev/null
@@ -1,301 +0,0 @@
-
-import os, sys
-WIDTH = 75
-
-plugins = [
-    ('advanced python testing',
-            'skipping mark pdb figleaf '
-            'monkeypatch coverage cov capture capturelog recwarn tmpdir',),
-    ('distributed testing, CI and deployment',
-        'xdist pastebin junitxml resultlog genscript',),
-    ('testing domains and conventions codecheckers',
-            'oejskit django unittest nose doctest restdoc'),
-    ('internal, debugging, help functionality',
-          'helpconfig terminal hooklog')
-    #('internal plugins / core functionality',
-    #    #'runner execnetcleanup # pytester',
-    #    'runner execnetcleanup' # pytester',
-    #)
-]
-
-externals = {
-    'oejskit': "run javascript tests in real life browsers",
-    'xdist': None,
-    'figleaf': None,
-    'capturelog': None,
-    'coverage': None,
-    'cov': None,
-    'codecheckers': None,
-    'django': "for testing django applications",
-}
-
-def warn(*args):
-    msg = " ".join(map(str, args))
-    print >>sys.stderr, "WARN:", msg
-
-class RestWriter:
-    _all_links = {}
-
-    def __init__(self, target):
-        self.target = py.path.local(target)
-        self.links = []
-
-    def _getmsg(self, args):
-        return " ".join(map(str, args))
-
-    def Print(self, *args, **kwargs):
-        msg = self._getmsg(args)
-        if 'indent' in kwargs:
-            indent = kwargs['indent'] * " "
-            lines = [(indent + x) for x in msg.split("\n")]
-            msg = "\n".join(lines)
-        self.out.write(msg)
-        if not msg or msg[-1] != "\n":
-            self.out.write("\n")
-        self.out.flush()
-
-    def sourcecode(self, source):
-        lines = str(source).split("\n")
-        self.Print(".. sourcecode:: python")
-        self.Print()
-        for line in lines:
-            self.Print("   ", line)
-
-    def _sep(self, separator, args):
-        msg = self._getmsg(args)
-        sep = len(msg) * separator
-        self.Print()
-        self.Print(msg)
-        self.Print(sep)
-        self.Print()
-
-
-    def h1(self, *args):
-        self._sep('=', args)
-
-    def h2(self, *args):
-        self._sep('-', args)
-
-    def h3(self, *args):
-        self._sep('+', args)
-
-    def li(self, *args):
-        msg = self._getmsg(args)
-        sep = "* %s" %(msg)
-        self.Print(sep)
-
-    def dt(self, term):
-        self.Print("``%s``" % term)
-
-    def dd(self, doc):
-        self.Print(doc, indent=4)
-
-    def para(self, *args):
-        msg = self._getmsg(args)
-        self.Print(msg)
-
-    def add_internal_link(self, name, path):
-        relpath = path.new(ext=".html").relto(self.target.dirpath())
-        self.links.append((name, relpath))
-
-    def write_links(self):
-        self.Print()
-        self.Print(".. include:: links.txt")
-        for link in self.links:
-            key = link[0]
-            if key in self._all_links:
-                assert self._all_links[key] == link[1], (key, link[1])
-            else:
-                self._all_links[key] = link[1]
-
-    def write_all_links(cls, linkpath):
-        p = linkpath.new(basename="links.txt")
-        p_writer = RestWriter(p)
-        p_writer.out = p_writer.target.open("w")
-        for name, value in cls._all_links.items():
-            p_writer.Print(".. _`%s`: %s" % (name, value))
-        p_writer.out.close()
-        del p_writer.out
-    write_all_links = classmethod(write_all_links)
-
-    def make(self, **kwargs):
-        self.out = self.target.open("w")
-        self.makerest(**kwargs)
-        self.write_links()
-
-        self.out.close()
-        print "wrote", self.target
-        del self.out
-
-class PluginOverview(RestWriter):
-    def makerest(self, config):
-        plugindir = py._pydir.join('plugin')
-        for cat, specs in plugins:
-            pluginlist = specs.split()
-            self.h1(cat)
-            for name in pluginlist:
-                oneliner = externals.get(name, None)
-                docpath = self.target.dirpath(name).new(ext=".txt")
-                if oneliner is not None:
-                    htmlpath = docpath.new(ext='.html')
-                    self.para("%s_ (external) %s" %(name, oneliner))
-                    self.add_internal_link(name, htmlpath)
-                else:
-                    doc = PluginDoc(docpath)
-                    doc.make(config=config, name=name)
-                    self.add_internal_link(name, doc.target)
-                    if name in externals:
-                        self.para("%s_ (external) %s" %(name, doc.oneliner))
-                    else:
-                        self.para("%s_ %s" %(name, doc.oneliner))
-                self.Print()
-
-class HookSpec(RestWriter):
-    def makerest(self, config):
-        for module in config.pluginmanager.hook._hookspecs:
-            source = py.code.Source(module)
-            self.h1("hook specification sourcecode")
-            self.sourcecode(source)
-
-class PluginDoc(RestWriter):
-    def makerest(self, config, name):
-        config.pluginmanager.import_plugin(name)
-        plugin = config.pluginmanager.getplugin(name)
-        assert plugin is not None, plugin
-        print plugin
-        doc = plugin.__doc__.strip()
-        i = doc.find("\n")
-        if i == -1:
-            oneliner = doc
-            moduledoc = ""
-        else:
-            oneliner = doc[:i].strip()
-            moduledoc = doc[i+1:].strip()
-
-        self.name = oneliner # plugin.__name__.split(".")[-1]
-        self.oneliner = oneliner
-        self.moduledoc = moduledoc
-
-        #self.h1("%s plugin" % self.name) # : %s" %(self.name, self.oneliner))
-        self.h1(oneliner)
-        #self.Print(self.oneliner)
-        self.Print()
-        self.Print(".. contents::")
-        self.Print("  :local:")
-        self.Print()
-
-        self.Print(moduledoc)
-
-        self.emit_funcargs(plugin)
-        self.emit_options(plugin)
-        if name not in externals:
-            self.emit_source(plugin, config.hg_changeset)
-        #self.sourcelink = (purename,
-        #    "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" +
-        #    purename + ".py")
-        #
-    def emit_source(self, plugin, hg_changeset):
-        basename = py.path.local(plugin.__file__).basename
-        if basename.endswith("pyc"):
-            basename = basename[:-1]
-        #self.para("`%s`_ source code" % basename)
-        #self.links.append((basename,
-        #    "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" +
-        #    basename))
-        self.h1("Start improving this plugin in 30 seconds")
-        self.para(py.code.Source("""
-            1. Download `%s`_ plugin source code
-            2. put it somewhere as ``%s`` into your import path
-            3. a subsequent ``py.test`` run will use your local version
-
-            Checkout customize_, other plugins_ or `get in contact`_.
-        """ % (basename, basename)))
-        #    your work appreciated if you offer back your version.  In this case
-        #    it probably makes sense if you `checkout the py.test
-        #    development version`_ and apply your changes to the plugin
-        #    version in there.
-        #self.links.append((basename,
-        #    "http://bitbucket.org/hpk42/py-trunk/raw/%s/"
-        #    "py/test/plugin/%s" %(hg_changeset, basename)))
-        self.links.append((basename,
-            "http://bitbucket.org/hpk42/py-trunk/raw/%s/"
-            "py/_plugin/%s" %(pyversion, basename)))
-        self.links.append(('customize', '../customize.html'))
-        self.links.append(('plugins', 'index.html'))
-        self.links.append(('get in contact', '../../contact.html'))
-        self.links.append(('checkout the py.test development version',
-            '../../install.html#checkout'))
-
-        if 0: # this breaks the page layout and makes large doc files
-            #self.h2("plugin source code")
-            self.Print()
-            self.para("For your convenience here is also an inlined version "
-                      "of ``%s``:" %basename)
-            #self(or copy-paste from below)
-            self.Print()
-            self.sourcecode(py.code.Source(plugin))
-
-    def emit_funcargs(self, plugin):
-        funcargfuncs = []
-        prefix = "pytest_funcarg__"
-        for name in vars(plugin):
-            if name.startswith(prefix):
-                funcargfuncs.append(getattr(plugin, name))
-        if not funcargfuncs:
-            return
-        for func in funcargfuncs:
-            argname = func.__name__[len(prefix):]
-            self.Print()
-            self.Print(".. _`%s funcarg`:" % argname)
-            self.Print()
-            self.h2("the %r test function argument" % argname)
-            if func.__doc__:
-                doclines = func.__doc__.split("\n")
-                source = py.code.Source("\n".join(doclines[1:]))
-                source.lines.insert(0, doclines[0])
-                self.para(str(source))
-            else:
-                self.para("XXX missing docstring")
-                warn("missing docstring", func)
-
-    def emit_options(self, plugin):
-        from pytest.parseopt import Parser
-        options = []
-        parser = Parser(processopt=options.append)
-        if hasattr(plugin, 'pytest_addoption'):
-            plugin.pytest_addoption(parser)
-        if not options:
-            return
-        self.h2("command line options")
-        self.Print()
-        formatter = py.std.optparse.IndentedHelpFormatter()
-        for opt in options:
-            switches = formatter.format_option_strings(opt)
-            self.Print("``%s``" % switches)
-            self.Print(opt.help, indent=4)
-
-if __name__ == "__main__":
-    if os.path.exists("py"):
-        sys.path.insert(0, os.getcwd())
-    import py
-    _config = py.test.config
-    _config.parse([])
-    _config.pluginmanager.do_configure(_config)
-
-    pydir = py.path.local(py.__file__).dirpath()
-    pyversion = py.version
-
-    cmd = "hg tip --template '{node}'"
-    old = pydir.dirpath().chdir()
-    _config.hg_changeset = py.process.cmdexec(cmd).strip()
-
-    testdir = pydir.dirpath("doc", 'test')
-
-    ov = PluginOverview(testdir.join("plugin", "index.txt"))
-    ov.make(config=_config)
-
-    ov = HookSpec(testdir.join("plugin", "hookspec.txt"))
-    ov.make(config=_config)
-
-    RestWriter.write_all_links(testdir.join("plugin", "links.txt"))
-
diff --git a/bin-for-dist/test_install.py b/bin-for-dist/test_install.py
deleted file mode 100644
index 88821f10f..000000000
--- a/bin-for-dist/test_install.py
+++ /dev/null
@@ -1,228 +0,0 @@
-import py
-import subprocess
-import os, sys
-
-execnet = py.test.importorskip("execnet")
-
-
-#
-# experimental funcargs for venv/install-tests
-#
-
-pytest_plugins = 'pytest_pytester',
-
-def pytest_funcarg__venv(request):
-    p = request.config.mktemp(request.function.__name__, numbered=True)
-    venv = VirtualEnv(str(p))
-    return venv
-
-def pytest_funcarg__py_setup(request):
-    testdir = request.getfuncargvalue('testdir')
-    rootdir = py.path.local(py.__file__).dirpath().dirpath()
-    setup = rootdir.join('setup.py')
-    if not setup.check():
-        py.test.skip("not found: %r" % setup)
-    return SetupBuilder(setup, testdir.tmpdir)
-
-class SetupBuilder:
-    def __init__(self, setup_path, tmpdir):
-        self.setup_path = setup_path
-        self.tmpdir = tmpdir
-        assert setup_path.check()
-
-    def make_sdist(self, destdir=None):
-        temp = self.tmpdir.mkdir('dist')
-        args = ['python', 'setup.py', 'sdist', '--dist-dir', str(temp)]
-        old = self.setup_path.dirpath().chdir()
-        try:
-            subcall(args)
-        finally:
-            old.chdir()
-        l = temp.listdir('py-*')
-        assert len(l) == 1
-        sdist = l[0]
-        if destdir is None:
-            destdir = self.setup_path.dirpath('build')
-            assert destdir.check()
-        else:
-            destdir = py.path.local(destdir)
-        target = destdir.join(sdist.basename)
-        sdist.copy(target)
-        return target
-
-def subcall(args):
-    if hasattr(subprocess, 'check_call'):
-        subprocess.check_call(args)
-    else:
-        subprocess.call(args)
-# code taken from Ronny Pfannenschmidt's virtualenvmanager
-
-class VirtualEnv(object):
-    def __init__(self, path):
-        #XXX: supply the python executable
-        self.path = path
-
-    def __repr__(self):
-        return "<VirtualEnv at %r>" %(self.path)
-
-    def _cmd(self, name):
-        if sys.platform == "win32":
-            return os.path.join(self.path, 'Scripts', name)
-        else:
-            return os.path.join(self.path, 'bin', name)
-
-    def ensure(self):
-        if not os.path.exists(self._cmd('python')):
-            self.create()
-
-    def create(self, sitepackages=False):
-        args = ['virtualenv', self.path]
-        if not sitepackages:
-            args.append('--no-site-packages')
-        subcall(args)
-
-    def makegateway(self):
-        python = self._cmd('python')
-        return execnet.makegateway("popen//python=%s" %(python,))
-
-    def pcall(self, cmd, *args, **kw):
-        self.ensure()
-        return subprocess.call([
-                self._cmd(cmd)
-            ] + list(args),
-            **kw)
-
-    def pytest_getouterr(self, *args):
-        self.ensure()
-        args = [self._cmd("py.test")] + list(args)
-        popen = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-        out, err = popen.communicate()
-        return out
-
-    def setup_develop(self):
-        self.ensure()
-        return self.pcall("python", "setup.py", "develop")
-
-    def easy_install(self, *packages, **kw):
-        args = []
-        if 'index' in kw:
-            index = kw['index']
-            if isinstance(index, (list, tuple)):
-                for i in index:
-                    args.extend(['-i', i])
-            else:
-                args.extend(['-i', index])
-
-        args.extend(packages)
-        self.pcall('easy_install', *args)
-
-
-def test_make_sdist_and_run_it(py_setup, venv):
-    sdist = py_setup.make_sdist(venv.path)
-    venv.easy_install(str(sdist))
-    gw = venv.makegateway()
-    ch = gw.remote_exec("import py ; channel.send(py.__version__)")
-    version = ch.receive()
-    assert version == py.__version__
-
-def test_plugin_setuptools_entry_point_integration(py_setup, venv, tmpdir):
-    sdist = py_setup.make_sdist(venv.path)
-    venv.easy_install(str(sdist))
-    # create a sample plugin
-    basedir = tmpdir.mkdir("testplugin")
-    basedir.join("setup.py").write("""if 1:
-        from setuptools import setup
-        setup(name="testplugin",
-            entry_points = {'pytest11': ['testplugin=tp1']},
-            py_modules = ['tp1'],
-        )
-    """)
-    basedir.join("tp1.py").write(py.code.Source("""
-        def pytest_addoption(parser):
-            parser.addoption("--testpluginopt", action="store_true")
-    """))
-    basedir.chdir()
-    print ("created sample plugin in %s" %basedir)
-    venv.setup_develop()
-    out = venv.pytest_getouterr("-h")
-    assert "testpluginopt" in out
-
-def test_cmdline_entrypoints(monkeypatch):
-    monkeypatch.syspath_prepend(py.path.local(__file__).dirpath().dirpath())
-    from setup import cmdline_entrypoints
-    versioned_scripts = ['py.test', 'py.which']
-    unversioned_scripts = versioned_scripts + [ 'py.cleanup',
-        'py.convert_unittest', 'py.countloc', 'py.lookup', 'py.svnwcrevert']
-    for ver in [(2,4,0), (2,5,0), (2,6,0), (2,7,0), (3,0,1), (3,1,1)]:
-        for platform in ('posix', 'win32'):
-            points = cmdline_entrypoints(ver, "posix", 'python')
-            for script in versioned_scripts:
-                script_ver = script + "-%s.%s" % ver[:2]
-                assert script_ver in points
-            for script in unversioned_scripts:
-                assert script in points
-    points = cmdline_entrypoints((2,5,1), "java1.6.123", 'jython')
-    for script in versioned_scripts:
-        expected = "%s-jython" % script
-        assert expected in points
-    for script in unversioned_scripts:
-        assert script in points
-
-    points = cmdline_entrypoints((2,5,1), "xyz", 'pypy-c-XYZ')
-    for script in versioned_scripts:
-        expected = "%s-pypy-c-XYZ" % script
-        assert expected in points
-    for script in unversioned_scripts:
-        assert script in points
-
-def test_slave_popen_needs_no_pylib(testdir, venv, pytestconfig):
-    pytestconfig.pluginmanager.skipifmissing("xdist")
-    venv.ensure()
-    #xxx execnet optimizes popen
-    #ch = venv.makegateway().remote_exec("import execnet")
-    #py.test.raises(ch.RemoteError, ch.waitclose)
-    python = venv._cmd("python")
-    p = testdir.makepyfile("""
-        import py
-        def test_func():
-            pass
-     """)
-    result = testdir.runpytest(p, '--rsyncdir=%s' % str(p),
-            '--dist=each', '--tx=popen//python=%s' % python)
-    result.stdout.fnmatch_lines([
-        "*1 passed*"
-    ])
-
-def test_slave_needs_no_execnet(testdir, sshhost, pytestconfig):
-    pytestconfig.pluginmanager.skipifmissing("xdist")
-    xspec = "ssh=%s" % sshhost
-    gw = execnet.makegateway("ssh=%s" % sshhost)
-    ch = gw.remote_exec("""
-        import os, subprocess
-        subprocess.call(["virtualenv", "--no-site-packages", "subdir"])
-        channel.send(os.path.join(os.path.abspath("subdir"), 'bin', 'python'))
-        channel.send(os.path.join(os.path.abspath("subdir")))
-    """)
-    try:
-        path = ch.receive()
-        chdir = ch.receive()
-    except ch.RemoteError:
-        e = sys.exc_info()[1]
-        py.test.skip("could not prepare ssh slave:%s" % str(e))
-    gw.exit()
-    newspec = "%s//python=%s//chdir=%s" % (xspec, path, chdir)
-    gw = execnet.makegateway(newspec)
-    ch = gw.remote_exec("import execnet")
-    py.test.raises(ch.RemoteError, ch.waitclose)
-    gw.exit()
-
-    p = testdir.makepyfile("""
-        import py
-        def test_func():
-            pass
-     """)
-    result = testdir.runpytest(p, '--rsyncdir=%s' % str(p),
-            '--dist=each', '--tx=%s' % newspec)
-    result.stdout.fnmatch_lines([
-        "*1 passed*"
-    ])