def test_write_section(self):

->     tempfile = temppath.ensure('filewriter', file=True)

       fw = self.get_filled_writer(FileWriter, tempfile)

       data = tempfile.read()

       assert len(data)

   def ensure(self, *args, **kwargs):

       """ ensure that an args-joined path exists (by default as

               a file). if you specify a keyword argument 'dir=True'

               then the path is forced to be a directory path.

           """

       p = self.join(*args)

       if kwargs.get('dir', 0):

           return p._ensuredirs()

       else:

->         p.dirpath()._ensuredirs()

           if not p.check(file=1):

               p.write("")

           return p

   def _ensuredirs(self):

       parent = self.dirpath()

       if parent == self:

           return self

       if parent.check(dir=0):

           parent._ensuredirs()

->     if self.check(dir=0):

           try:

               self.mkdir()

           except py.error.EEXIST:

               # race condition: file/dir created by another thread/process.

               # complain if it is not a dir

               if self.check(dir=0):

                   raise

       return self

   def check(self, **kw):

       """ check a path for existence, or query its properties

               without arguments, this returns True if the path exists (on the

               filesystem), False if not

               with (keyword only) arguments, the object compares the value

               of the argument with the value of a property with the same name

               (if it has one, else it raises a TypeError)

               when for example the keyword argument 'ext' is '.py', this will

               return True if self.ext == '.py', False otherwise

           """

       if kw:

           kw = kw.copy()

           if not checktype(self, kw):

               return False

       else:

           kw = {'exists' : 1}

->     return self.Checkers(self)._evaluate(kw)

   def _evaluate(self, kw):

       for name, value in kw.items():

           invert = False

           meth = None

           try:

               meth = getattr(self, name)

           except AttributeError:

               if name[:3] == 'not':

                   invert = True

                   try:

                       meth = getattr(self, name[3:])

                   except AttributeError:

                       pass

           if meth is None:

               raise TypeError, "no %r checker available for %r" % (name, self.path)

           try:

               if meth.im_func.func_code.co_argcount > 1:

                   if (not meth(value)) ^ invert:

                       return False

               else:

->                 if bool(value) ^ bool(meth()) ^ invert:

                       return False

           except (py.error.ENOENT, py.error.ENOTDIR):

               for name in self._depend_on_existence:

                   if name in kw:

                       if kw.get(name):

                           return False

                   name = 'not' + name

                   if name in kw:

                       if not kw.get(name):

                           return False

       return True

   def dir(self):

->     return stat.S_ISDIR(self._stat().mode)

   def _stat(self):

       try:

           return self._statcache

       except AttributeError:

           try:

->             self._statcache = self.path.stat()

           except py.error.ELOOP:

               self._statcache = self.path.lstat()

           return self._statcache