def test():
    if not os.path.isfile('a.out'):
        sh.echo('No executable found', _out='results.txt')
        return
    
    result = sh.Command('./a.out')
    result(_out='results.txt')

    def test_should_not_pop_stash_on_failure(self):
        from sh import echo

        git_touch_add_commit('foo', 'bar', 'moo')
        foo_commit, _ = git_log_oneline()[2]

        echo('bar', _out='bar')
        echo('moo', _out='moo')
        git('add', 'bar')

        expected = {
            'bar': 'M ',
            'moo': ' M'
        }
        self.assertEqual(expected, git_status())

        with self.assertRaises(GitRebaseFailed):
            fix(foo_commit)

        status = {
            'bar': 'DU'
        }
        self.assertEqual(status, git_status())

        self.assertEqual(1, git_stash_len())

        actual = git_show('HEAD')['subject']
        expected = git_show(foo_commit)['subject']
        self.assertEqual(expected, actual)

 def setUp(self, set_pincode_by_id):
     sh.echo("1234, 1234", _out="/run/shm/cellular.tmp")
     try:
         os.unlink(dirpath + "/../data/cellular.json")
     except Exception:
         pass
     set_pincode_by_id.return_value = True
     self.cellular = Cellular(connection=Mockup())

def echo_hello_world_cmd(**kwargs):
    """
    Usage:
        echo hello world --user <user> <target> [--chinese (yes|no)]

    Options:
        --user <user>             Hello World [default: root]
        -c,--chinese              Use Chinese to say hello world
    """
    print echo("echo hello world:" + kwargs["user"])

    def test_should_rollback_on_failure_if_requested(self):
        from sh import echo

        git_touch_add_commit('foo', 'bar')
        foo_commit, _ = git_log_oneline()[1]
        echo('bar', _out='bar')
        git('add', 'bar')

        with self.assertRaises(GitRebaseFailed):
            with git_state_invariant():
                fix('--atomic', foo_commit)

 def convert(match):
     source = match.groups()[0]
     source = '\n'.join(l.strip() for l in source.split('\n'))
     source = "<pre>%s</pre>" % source
     rst_source = pandoc(echo(source), f='html', t='rst').stdout.decode('utf8')
     # rst_source = rst_source.strip().replace('\n', '\n   ') + '\n'
     return rst_source

    def test_unicode_arg(self):
        from sh import echo
        if IS_PY3: test = "漢字"
        else: test = "漢字".decode("utf8")
        p = echo(test).strip()

        self.assertEqual(test, p)

    def test_search(self):
        """Make sure aspiration search is the same as ordinary search
        Uses random fens as values, so not guaranteed to produce the same
        output when run multiple times"""
        lines = str(sh.rl("test/data/fenio.fens", "--count=10")).rstrip("\n")

        sh.make("aspire_search")
        run = sh.Command("./aspire_search")
        aspire_output = str(run(sh.echo(lines)))

        sh.make("no_aspire_search")
        run = sh.Command("./no_aspire_search")
        no_aspire_output = str(run(sh.echo(lines)))

        for fen_orig, fen1, fen2 in zip(lines.split("\n"), aspire_output.split("\n"), no_aspire_output.split("\n")):
            self.assertEquals(fen1, fen2, "Original fen: '%s'" % fen_orig)

def avi_seek(seek):
  fifo = '/tmp/omxplayer_fifo'

  direction = ''
  if seek == 1:
    direction = "$'\x1b\x5b\x42'"
  elif seek == 2:
    direction = "$'\x1b\x5b\x44'"
  elif seek == 3:
    direction = "$'\x1b\x5b\x43'"
  elif seek == 4:
    direction = "$'\x1b\x5b\x41'"
  else:
    direction = "."

  sh.echo('-n', direction, '>', fifo, _bg=True)

    def test_stringio_output(self):
        from sh import echo
        if IS_PY3:
            from io import StringIO
            from io import BytesIO as cStringIO
        else:
            from StringIO import StringIO
            from cStringIO import StringIO as cStringIO

        out = StringIO()
        echo("-n", "testing 123", _out=out)
        self.assertEqual(out.getvalue(), "testing 123")

        out = cStringIO()
        echo("-n", "testing 123", _out=out)
        self.assertEqual(out.getvalue().decode(), "testing 123")

 def test_unicode_arg(self):
     from sh import echo
     
     test = "漢字"
     if not IS_PY3: test = test.decode("utf8")
     
     p = echo(test).strip()
     self.assertEqual(test, p)

    def say(self, message, voice=None, block=True):
        if not voice:
            voice = self.default_voice

        voice_part = '(voice_{0})'.format(voice)
        text_part = '(SayText "{0}")'.format(common.sterilize(message))
        command = voice_part + text_part
        festival(echo(command), _bg=not block)

def run_jbofihe(args, lojban):
    """ In order to pipe correctly we have to use two commandline wrappers. """
    try:
        return sh.jbofihe(sh.echo(lojban), *args.split())
    except Exception, e:
        print "Got an error: %s" % type(e)
        print "It reads:"
        print e.message
        print "The Exception vanishes in a puff of lojic."
        sys.exit()

def say_sync(text):
    to_say = echo(text)
    audio = festival_client(to_say, ttw=True)
    paplay( audio,
            channels=1,
            raw=True,
            format="s16le",
            rate=32000,
            device="teesink",
    )

    def test_unicode_arg(self):
        from sh import echo

        test = "漢字"
        if not IS_PY3:
            test = test.decode("utf8")

        p = echo(test, _encoding="utf8")
        output = p.strip()
        self.assertEqual(test, output)

    def create_loop(self, loop, path, size):
        """Create a new loopback device."""
        is_in = self.find_loop(loop)
        if is_in:
            raise Exception("loop device already installed: %s / %s" % is_in)

        self.ssh.dd("if=/dev/zero", "of=%s" % path, "bs=1M", "count=%d" % size)
        self.ssh.fdisk(sh.echo("-e", r"o\nn\np\n1\n\n\nw"), path)
        self.ssh.losetup(loop, path)

        is_in = self.find_loop(loop)
        if not is_in:
            raise Exception("fail to create loop device: %s / %s" % is_in)

def create_base(folder):
    """
    Create multisite Plone hosting infrastructure on a server..

    Host sites at /srv/plone or chosen cache_folder

    Each folder has a file called buildout.cfg which is the production buildout file
    for this site. This might not be a real file, but a symlink to a version controlled
    file under /srv/plone/xxx/src/yoursitecustomization.policy/production.cfg.

    Log rotate is performed using a global UNIX log rotate script:
    http://opensourcehacker.com/2012/08/30/autodiscovering-log-files-for-logrotate/

    :param folder: Base installation folder for all the sites e.g. /srv/plone
    """
    from sh import apt_get

    with sudo:

        # Return software we are going to need in any case
        # Assumes Ubuntu / Debian
        # More info: https://github.com/miohtama/ztanesh
        if (not which("zsh")) or (not which("git")) or (not which("gcc")):
            # Which returs zero on success
            print "Installing OS packages"
            apt_get("update")
            apt_get("install", "-y", *PACKAGES)

        # Create base folder
        if not os.path.exists(folder):
            print "Creating installation base %s" % folder
            install(folder, "-d")

        # Create nightly restart cron job
        if os.path.exists("/etc/cron.d"):
            print "(Re)setting all sites nightly restart cron job"
            echo(CRON_TEMPLATE, _out=CRON_JOB)

    create_python_env(folder)

def create_python_env(folder):
    """
    Compile a Python environment with various Python versions to run Plone.

    Create Python's under /srv/plone/python

    Use https://github.com/collective/buildout.python
    """
    from sh import git

    python_target = os.path.join(folder, "python")

    print "Setting up various Python versions at %s" % python_target

    with sudo:

        if not os.path.exists(python_target):
            cd(folder)
            git("clone", "git://github.com/collective/buildout.python.git", "python")

        if not os.path.exists(os.path.join(python_target, "python-2.7", "bin", "python")):
            cd(python_target)
            echo(PYTHON_BUILDOUT, _out="%s/buildout.cfg" % python_target)
            python("bootstrap.py")
            run = Command("%s/bin/buildout" % python_target)
            run()

        pip = Command("%s/python-2.7/bin/pip" % python_target)

        # Avoid buildout bootstrap global python write bug using Distribute 0.6.27
        pip("install", "--upgrade", "Distribute")

        # Plone 4.x sites heavily rely on lxml
        # Create a shared lxml installation. System deps should have been installed before.
        # for plone 3.x do this by hand
        # collective.buildout.python does not do lxml, which is crucial
        pip("install", "lxml")

def create_site_initd_script(name, folder, username):
    """
    Install /etc/init.d boot script for a Plone site.

    We do this Ubuntu style, not sure if works 100% on Debian.

    http://wiki.debian.org/LSBInitScripts

    http://developer.plone.org/hosting/restarts.html#lsbinitscripts-starting-with-debian-6-0
    """

    from sh import chmod

    updaterc = Command("/usr/sbin/update-rc.d")

    script_body = DEBIAN_BOOT_TEMPLATE % dict(user=username, folder=folder, name=name)

    initd_script = "/etc/init.d/%s" % name

    print "Creating start/stop script %s" % initd_script
    with sudo:
        echo(script_body, _out=initd_script)
        chmod("u+x", initd_script)
        updaterc(name, "defaults")

    def set_hostname(self, hostname):
        """Update hostname

            Args:
                hostname (str): hostname to be updated
        """
        try:
            old_hostname = self.get_hostname()

            is_valid_hostname(hostname)

            sh.hostname("-b", hostname)
            sh.echo(hostname, _out="/etc/hostname")

            try:
                # sed -i 's/ old$/ new/g' /etc/hosts
                sh.sed("-i", "s/ {}$/ {}/g".format(old_hostname, hostname),
                       "/etc/hosts")
            except:
                with open("/etc/hosts", "a") as f:
                    f.write("127.0.0.1       localhost {}\n".format(hostname))
            self.update(id=1, newObj={"hostname": hostname})
        except Exception as e:
            raise e