def do_release(self):
     if self.fd is not None:
         posix.ftruncate(self.fd, 0)
         fcntl.flock(self.fd, fcntl.LOCK_UN)
         posix.close(self.fd)
         self.fd = None
         self._locked = False

 def test_ignore_ioerror_in_readall_if_nonempty_result(self):
     # this is the behavior of regular files in CPython 2.7, as
     # well as of _io.FileIO at least in CPython 3.3.  This is
     # *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
     # see CPython's issue #21090.
     import sys
     try:
         from posix import openpty, fdopen, write, close
     except ImportError:
         skip('no openpty on this platform')
     if 'gnukfreebsd' in sys.platform:
         skip('close() hangs forever on kFreeBSD')
     read_fd, write_fd = openpty()
     write(write_fd, 'Abc\n')
     close(write_fd)
     f = fdopen(read_fd)
     # behavior on Linux: f.read() returns 'Abc\r\n', then the next time
     # it raises IOError.  Behavior on OS/X (Python 2.7.5): the close()
     # above threw away the buffer, and f.read() always returns ''.
     if sys.platform.startswith('linux'):
         s = f.read()
         assert s == 'Abc\r\n'
         raises(IOError, f.read)
     else:
         s = f.read()
         assert s == ''
         s = f.read()
         assert s == ''
     f.close()

        def do_acquire(self, waitflag=False):
            locked = False

            if waitflag:
                blockflag = 0
            else:
                blockflag = fcntl.LOCK_NB

            self.fd = posix.open(self.fn, O_CREAT | O_RDWR, 0600)
            try:
                fcntl.flock(self.fd, fcntl.LOCK_EX|blockflag)
                # locked it
                try:
                    posix.ftruncate(self.fd, 0)
                    posix.write(self.fd, `os.getpid()` + '\n')
                    locked = True
                except:
                    self.do_release()
                    raise
            except IOError, x:
                if x.errno == errno.EWOULDBLOCK:
                    # failed to lock
                    posix.close(self.fd)
                    del self.fd
                else:
                    raise

 def test_rename_at_close_correct_read(self):
     firstFileFd = posix.open("mount/file1", posix.O_RDONLY)
     secondFileFd = posix.open("mount/file2", posix.O_RDONLY)
     for i in range(1000):
         position = random.randint(0, 10000)
         size = random.randint(1, 10000)
         posix.lseek(firstFileFd,position, 0)
         posix.lseek(secondFileFd, position, 0)
         posix.read(firstFileFd, size)
         posix.read(secondFileFd, size)
     posix.close(firstFileFd)
     posix.close(secondFileFd)
     posix.rename("mount/file2", "mount/file3")
     posix.rename("mount/file1","mount/file2")
     self.assertTrue(open("mount/file2").read()== open("src/file2").read())

 def one_loop(self):
     ret = True
     for (fd, ev) in self.poller.poll(1000):
         if ev & (select.POLLERR | select.POLLHUP):
             self.flush_outputs()
             self.poller.unregister(fd)
             ret = False
         if ev & select.POLLIN:
             data = posix.read(fd, 4096)
             if not data:
                 posix.close(self.fd_map[fd])
                 ret = False
             self.queue_write(self.fd_map[fd], data)
         if ev & select.POLLOUT:
             self.do_write(fd)
     return ret

    def make_tempfile(fn, pid):
        tfn = os.path.join(os.path.dirname(fn), 'shlock%d.tmp' % pid)

        errcount = 1000
        while 1:
            try:
                fd = posix.open(tfn, O_EXCL | O_CREAT | O_RDWR, 0600)
                posix.write(fd, '%d\n' % pid)
                posix.close(fd)

                return tfn
            except OSError, x:
                if (errcount > 0) and (x.errno == errno.EEXIST):
                    os.unlink(tfn)
                    errcount = errcount - 1
                else:
                    raise

 def test_ignore_ioerror_in_readall_if_nonempty_result(self):
     # this is the behavior of regular files in CPython 2.7, as
     # well as of _io.FileIO at least in CPython 3.3.  This is
     # *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
     # see CPython's issue #21090.
     try:
         from posix import openpty, fdopen, write, close
     except ImportError:
         skip('no openpty on this platform')
     read_fd, write_fd = openpty()
     write(write_fd, 'Abc\n')
     close(write_fd)
     f = fdopen(read_fd)
     s = f.read()
     assert s == 'Abc\r\n'
     raises(IOError, f.read)
     f.close()

def jog_i2c_write(addr, register, value, debug):
    import fcntl
    import posix

    n_i2c = 0
    f_i2c = posix.open("/dev/i2c-%i" % n_i2c, posix.O_RDWR)

    flags = I2C_M_WR
    buf = ctypes.create_string_buffer(2)
    buf[0] = chr(register)
    buf[1] = chr(value)
    msgs = I2cMsg(addr=addr, flags=flags, len=ctypes.sizeof(buf), buf=buf)
    msg_array, msg_count = i2c_ioctl_msg(msgs)
    io_i2c = I2cRdwrIoctlData(msgs=msg_array, nmsgs=msg_count)
    i2c_stat = fcntl.ioctl(f_i2c, I2C_RDWR, io_i2c)

    posix.close(f_i2c)

    def test_rename_folder_correct_read(self):
        os.mkdir("src/folder1")
        os.mkdir("src/folder2")
        os.system("cp src/file1 src/folder1/file") 
        os.system("cp src/file2 src/folder2/file") 


        firstFileFd = posix.open("mount/folder1/file", posix.O_RDONLY)
        secondFileFd = posix.open("mount/folder2/file", posix.O_RDONLY)
        for i in range(1000):
            position = random.randint(0, 10000)
            size = random.randint(1, 10000)
            posix.lseek(firstFileFd,position, 0)
            posix.lseek(secondFileFd, position, 0)
            posix.read(firstFileFd, size)
            posix.read(secondFileFd, size)
        posix.rename("mount/folder2", "mount/folder3")
        posix.rename("mount/folder1","mount/folder2")
        posix.close(firstFileFd)
        posix.close(secondFileFd)
        self.assertTrue(open("mount/folder2/file").read()== open("src/folder2/file").read())

 def test_randomAccessToFile(self):
     position = 0
     size = 0
     srcFileFd = posix.open("src/file1", posix.O_RDONLY)
     mountFileFd = posix.open("mount/file1", posix.O_RDONLY)
     for i in range(10000):
         position = random.randint(0, 10000)
         size = random.randint(1, 10000)
         posix.lseek(srcFileFd,position, 0)
         posix.lseek(mountFileFd, position, 0)
         if (posix.read(srcFileFd,size) !=  posix.read(mountFileFd, size)):
             posix.close(srcFileFd)
             posix.close(mountFileFd)
             self.assertTrue(False)
     posix.close(srcFileFd)
     posix.close(mountFileFd)

def daemonize(logfile):
    try:
        from os import fork
        from posix import close
    except:
        print 'Daemon mode is not supported on this platform (missing fork() syscall or posix module)'
        sys_exit(-1)

    import sys
    if (fork()): sys_exit(0) # parent return to shell

    ### Child
    close(sys.stdin.fileno())
    sys.stdin  = open('/dev/null')
    close(sys.stdout.fileno())
    sys.stdout = Log(open(logfile, 'a+'))
    close(sys.stderr.fileno())
    sys.stderr = Log(open(logfile, 'a+'))
    chdir('/')

 def close(self):
     """
     Closes the I2C bus device.
     """
     posix.close(self.fd)

 def __del__(self):
     try:
         posix.close(self.fd)
     except AttributeError:
         pass #Do nothing in this case.

 def close(self):
     """
     Closes the file descriptor.
     """
     posix.close(self.fd)

 def close(self):
     """Closes the SPI device file descriptor."""
     posix.close(self.fd)
     self.fd = None

 def test_dont_close_fd_if_dir_check_fails_in_fdopen(self):
     import posix
     fd = posix.open('/', posix.O_RDONLY)
     raises(IOError, posix.fdopen, fd)
     posix.close(fd)

def deinit():
    """Closes the SPI device file descriptor."""
    global spidev_fd
    if spidev_fd:
        posix.close(spidev_fd)
    spidev_fd = None

 def close_fd(self):
     posix.close(self.fd)
     del self.fd

 def close_fd(self):
     posix.close(self.fd)
     self.fd = None

	def close(self):
		dummy = posix.close(self.fd)