diff -uprN ltp.old/testcases/kernel/syscalls/inotify/inotify01.c ltp/testcases/kernel/syscalls/inotify/inotify01.c
--- ltp.old/testcases/kernel/syscalls/inotify/inotify01.c	1970-01-01 03:00:00.000000000 +0300
+++ ltp/testcases/kernel/syscalls/inotify/inotify01.c	2007-05-22 17:23:23.000000000 +0400
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) 2007 SWSoft.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Started by Andrew Vagin <avagin@sw.ru>
+ *
+ */
+/*
+ * NAME
+ *     inotify01
+ *
+ * DESCRIPTION
+ *     Check that inotify work for a file
+ *
+ * ALGORITHM
+ *     Execute sequence file's operation and check return events
+ *
+ */
+
+#include <sys/inotify.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include "test.h"
+#include "usctest.h"
+
+#define EVENT_MAX 1024
+/* size of the event structure, not counting name */
+#define EVENT_SIZE  (sizeof (struct inotify_event))
+/* reasonable guess as to size of 1024 events */
+#define EVENT_BUF_LEN        (EVENT_MAX * (EVENT_SIZE + 16))
+
+void setup();
+void cleanup();
+
+
+
+char *TCID="inotify01";         /* Test program identifier.    */
+int TST_TOTAL = 7;            /* Total number of test cases. */
+extern int Tst_count;        /* Test Case counter for tst_* routines */
+
+#define BUF_SIZE 256
+char fname[BUF_SIZE];
+char buf[BUF_SIZE];
+int fd, fd_notify;
+uint32_t wd;
+
+int event_set[EVENT_MAX];
+
+int main(int ac, char **av){
+    int lc;        /* loop counter */
+    char *msg;        /* message returned from parse_opts */
+    
+    /*
+     * parse standard options
+     */
+    if ( (msg=parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *) NULL )
+        tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
+
+    /*
+     * perform global setup for test
+     */
+    setup();
+
+    /*
+     * check looping state if -c option given
+     */
+
+    for (lc=0; TEST_LOOPING(lc); lc++) {
+        Tst_count = 0;
+        /* reset Tst_count in case we are looping. */
+
+        /*
+         * generate sequence of events
+         */
+        if (chmod(fname, 0755) < 0) {
+            tst_brkm(TBROK, cleanup,
+                    "chmod(%s, 0755) Failed, errno=%d : %s",
+                    fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_ATTRIB;
+        Tst_count++;
+
+        if ((fd = open(fname, O_RDONLY)) == -1) {
+            tst_brkm(TBROK, cleanup,
+              "open(%s, O_RDWR|O_CREAT,0700) Failed, errno=%d : %s",
+              fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_OPEN; 
+        Tst_count++;
+
+        if (read(fd, buf, BUF_SIZE) == -1) {
+            tst_brkm(TBROK, cleanup,
+                    "read(%d, buf, %d) Failed, errno=%d : %s",
+                    fd, BUF_SIZE, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_ACCESS;
+        Tst_count++;
+
+        if (close(fd) == -1) {
+            tst_brkm(TBROK, cleanup, 
+                    "close(%s) Failed, errno=%d : %s", 
+                    fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_CLOSE_NOWRITE;
+        Tst_count++;
+
+
+        if ((fd = open(fname,O_RDWR|O_CREAT,0700)) == -1) {
+            tst_brkm(TBROK, cleanup,
+              "open(%s, O_RDWR|O_CREAT,0700) Failed, errno=%d : %s",
+              fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_OPEN;
+        Tst_count++;
+
+        if (write(fd, buf, BUF_SIZE) == -1) {
+            tst_brkm(TBROK, cleanup,
+                "write(%d, %s, 1) Failed, errno=%d : %s",
+                fd, fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_MODIFY;
+        Tst_count++;
+
+        if (close(fd) == -1) {
+            tst_brkm(TBROK, cleanup, 
+                    "close(%s) Failed, errno=%d : %s", 
+                    fname, errno, strerror(errno));
+        }
+        event_set[Tst_count] = IN_CLOSE_WRITE;
+        Tst_count++;
+        
+        if (TST_TOTAL != Tst_count) {
+            tst_brkm(TBROK, cleanup,
+                    "TST_TOTAL and Tst_count are not equal");
+        }
+        Tst_count = 0;
+
+        /*
+         * get list on events
+         */
+        char event_buf[EVENT_BUF_LEN];
+        int len, i = 0, test_num = 0;
+        if ((len = read(fd_notify, event_buf, EVENT_BUF_LEN)) < 0) {
+            tst_brkm(TBROK, cleanup,
+                "read(%d, buf, %d) Failed, errno=%d : %s",
+                fd_notify, EVENT_BUF_LEN, errno,
+                strerror(errno));
+
+        }
+            
+        /*
+         * check events
+         */
+        while (i < len) {
+            struct inotify_event *event;
+            event = (struct inotify_event *) &event_buf[i];
+            if (test_num >= TST_TOTAL) {
+                tst_resm(TFAIL, 
+                    "get unnecessary event: wd=%d mask=%x "
+                    "cookie=%u len=%u",
+                    event->wd, event->mask,
+                    event->cookie, event->len);
+            } else if (event_set[test_num] == event->mask){
+                tst_resm(TPASS, "get event: wd=%d mask=%x" 
+                    " cookie=%u len=%u",
+                    event->wd, event->mask,
+                    event->cookie, event->len);
+
+            } else {
+                tst_resm( TFAIL, "get event: wd=%d mask=%x "
+                    "(expected %x) cookie=%u len=%u",
+                    event->wd, event->mask,    
+                    event_set[test_num],
+                    event->cookie, event->len);
+            }
+            test_num++;
+            i += EVENT_SIZE + event->len;
+        }
+        for (; test_num<TST_TOTAL; test_num++){
+            tst_resm(TFAIL, "don't get event: mask=%x ",
+                    event_set[test_num]);
+
+        }
+
+    }    /* End for TEST_LOOPING */
+
+    /*
+     * cleanup and exit
+     */
+    cleanup();
+
+    return 0;
+}    /* End main */
+
+/*
+ * setup() - performs all ONE TIME setup for this test.
+ */
+void setup(){
+    /* capture signals */
+    tst_sig(NOFORK, DEF_HANDLER, cleanup);
+
+    /* Pause if that option was specified */
+    TEST_PAUSE;
+
+    /* make a temp directory and cd to it */
+    tst_tmpdir();
+
+    sprintf(fname,"tfile_%d",getpid());
+    if ((fd = open(fname,O_RDWR|O_CREAT,0700)) == -1) {
+        tst_brkm(TBROK, cleanup,
+            "open(%s, O_RDWR|O_CREAT,0700) Failed, errno=%d : %s",
+            fname, errno, strerror(errno));
+    }
+    if (( write(fd, fname, 1)) == -1) {
+        tst_brkm(TBROK, cleanup,
+                "write(%d, %s, 1) Failed, errno=%d : %s",
+                fd, fname, errno, strerror(errno));
+    }
+
+    /* close the file we have open */
+    if (close(fd) == -1) {
+        tst_brkm(TBROK, cleanup,
+                "close(%s) Failed, errno=%d : %s", 
+                fname, errno, strerror(errno));
+    }
+    if ((fd_notify = inotify_init ()) < 0) {
+        if( errno == ENOSYS ){
+            tst_resm(TCONF,"inotify is not configured in this kernel.");
+            tst_resm(TCONF,"Test will not run.");
+            tst_exit();
+        }else{
+            tst_brkm(TBROK, cleanup,
+                "inotify_init () Failed, errno=%d : %s",
+                errno, strerror(errno));
+        }
+    }
+
+    if ((wd = inotify_add_watch (fd_notify, fname, IN_ALL_EVENTS)) < 0){
+        tst_brkm(TBROK, cleanup,
+                "inotify_add_watch (%d, %s, IN_ALL_EVENTS)" 
+                "Failed, errno=%d : %s",
+                fd_notify, fname, errno, strerror(errno));
+    };
+
+}    /* End setup() */
+
+
+/*
+ * cleanup() - performs all ONE TIME cleanup for this test at
+ *        completion or premature exit.
+ */
+void cleanup(){
+    if (inotify_rm_watch(fd_notify, wd) < 0) {
+        tst_resm(TWARN,    "inotify_rm_watch (%d, %d) Failed,"
+                "errno=%d : %s",
+                fd_notify, wd, errno, strerror(errno));
+
+    }
+
+    if (close(fd_notify) == -1) {
+        tst_resm(TWARN, "close(%d) Failed, errno=%d : %s", 
+                fd_notify, errno, strerror(errno));
+    }
+
+
+    /*
+     * print timing stats if that option was specified.
+     * print errno log if that option was specified.
+     */
+    TEST_CLEANUP;
+
+    /* Remove tmp dir and all files in it */
+    tst_rmdir();
+
+    /* exit with return code appropriate for results */
+    tst_exit();
+}    /* End cleanup() */
diff -uprN ltp.old/testcases/kernel/syscalls/inotify/inotify02.c ltp/testcases/kernel/syscalls/inotify/inotify02.c
--- ltp.old/testcases/kernel/syscalls/inotify/inotify02.c	1970-01-01 03:00:00.000000000 +0300
+++ ltp/testcases/kernel/syscalls/inotify/inotify02.c	2007-05-24 18:05:52.000000000 +0400
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2007 SWSoft.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Started by Andrew Vagin <avagin@sw.ru>
+ *
+ */
+/****************************************************************************
+ * NAME
+ *     inotify02
+ *
+ * DESCRIPTION
+ *     Check that inotify work for a directory
+ *
+ * ALGORITHM
+ *     Execute sequence file's operation and check return events
+ *
+ * ***************************************************************************/
+#include <sys/inotify.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include "test.h"
+#include "usctest.h"
+
+#define EVENT_MAX 1024
+/* size of the event structure, not counting name */
+#define EVENT_SIZE  (sizeof (struct inotify_event))
+/* reasonable guess as to size of 1024 events */
+#define EVENT_BUF_LEN        (EVENT_MAX * (EVENT_SIZE + 16))
+
+void setup();
+void cleanup();
+
+
+
+char *TCID="inotify02";         /* Test program identifier.    */
+int TST_TOTAL=9;            /* Total number of test cases. */
+extern int Tst_count;        /* Test Case counter for tst_* routines */
+
+#define BUF_SIZE 256
+char fname1[BUF_SIZE], fname2[BUF_SIZE];
+char buf[BUF_SIZE];
+int fd, fd_notify;
+uint32_t wd;
+
+struct event_t {
+        char name[BUF_SIZE];
+        uint32_t mask;
+        uint32_t len;
+};
+#define FILE_NAME1 "test_file1"
+#define FILE_NAME2 "test_file2"
+
+struct event_t event_set [EVENT_MAX];
+
+int main(int ac, char **av){
+    int lc;        /* loop counter */
+    char *msg;        /* message returned from parse_opts */
+
+    /*
+     * parse standard options
+     */
+    if ((msg=parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *) NULL)
+        tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
+
+    /*
+     * perform global setup for test
+     */
+    setup();
+
+    /*
+     * check looping state if -c option given
+     */
+    for (lc=0; TEST_LOOPING(lc); lc++) {
+
+        /* reset Tst_count in case we are looping. */
+        Tst_count = 0;
+
+        /*
+         * generate sequence of events
+         */
+        if (chmod(".", 0755) < 0) {
+            tst_brkm(TBROK, cleanup,
+                "chmod(\".\", 0755) Failed, errno=%d : %s",
+                     errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_ISDIR | IN_ATTRIB;
+        strcpy(event_set[Tst_count].name, "");
+        Tst_count++;
+
+        if ((fd = creat(FILE_NAME1, 0755)) == -1) {
+            tst_brkm(TBROK, cleanup,
+                "creat(\"%s\", 755) Failed, errno=%d : %s",
+                fname1, errno, strerror(errno));
+        }
+        
+        event_set[Tst_count].mask = IN_CREATE;
+        strcpy(event_set[Tst_count].name, FILE_NAME1);
+        Tst_count++;
+        event_set[Tst_count].mask = IN_OPEN;
+        strcpy(event_set[Tst_count].name, FILE_NAME1);
+        Tst_count++;
+
+        if (close(fd) == -1) {
+            tst_brkm(TBROK, cleanup, 
+                    "close(%s) Failed, errno=%d : %s", 
+                    fname1, errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_CLOSE_WRITE;
+        strcpy(event_set[Tst_count].name, FILE_NAME1);
+        Tst_count++;
+
+        if (rename(FILE_NAME1, FILE_NAME2) == -1){
+            tst_brkm(TBROK, cleanup, 
+                    "rename(%s, %s) Failed, errno=%d : %s",
+                    FILE_NAME1, FILE_NAME2,
+                    errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_MOVED_FROM;
+        strcpy(event_set[Tst_count].name, FILE_NAME1);
+        Tst_count++;
+        event_set[Tst_count].mask = IN_MOVED_TO;
+        strcpy(event_set[Tst_count].name, FILE_NAME2);
+        Tst_count++;
+
+
+
+        if (unlink(FILE_NAME2) == -1){
+            tst_brkm(TBROK, cleanup, 
+                    "unlink(%s) Failed, errno=%d : %s",
+                    FILE_NAME2,
+                    errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_DELETE;
+        strcpy(event_set[Tst_count].name, FILE_NAME2);
+        Tst_count++;
+
+
+        if (getcwd(fname1, BUF_SIZE) == NULL){
+            tst_brkm(TBROK, cleanup, 
+                    "getcwd(%x, %d) Failed, errno=%d : %s",
+                    fname1, BUF_SIZE,
+                    errno, strerror(errno));
+        }
+
+        snprintf(fname2, BUF_SIZE, "%s.rename", fname1);
+        if (rename(fname1, fname2) == -1){
+            tst_brkm(TBROK, cleanup, 
+                    "rename(%s, %s) Failed, errno=%d : %s",
+                    fname1, fname2,
+                    errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_MOVE_SELF;
+        strcpy(event_set[Tst_count].name, "");
+        Tst_count++;
+
+
+        if (rename(fname2, fname1) == -1){
+            tst_brkm(TBROK, cleanup, 
+                    "rename(%s, %s) Failed, errno=%d : %s",
+                    fname1, fname2,
+                    errno, strerror(errno));
+        }
+        event_set[Tst_count].mask = IN_MOVE_SELF;
+        strcpy(event_set[Tst_count].name, "");
+        Tst_count++;
+
+        if (Tst_count != TST_TOTAL) {
+            tst_brkm(TBROK, cleanup, 
+                "Tst_count and TST_TOTAL are not equal");
+        }
+        
+        Tst_count = 0;
+
+
+        char event_buf[EVENT_BUF_LEN];
+        int len, i = 0, test_num = 0;
+        if ((len = read(fd_notify, event_buf, EVENT_BUF_LEN)) < 0) {
+            tst_brkm(TBROK, cleanup,
+                "read(%d, buf, %d) Failed, errno=%d : %s",
+                fd_notify, EVENT_BUF_LEN, 
+                errno, strerror(errno));
+
+        }
+
+        while (i < len) {
+            struct inotify_event *event;
+            event = (struct inotify_event *) &event_buf[i];
+            if (test_num >= TST_TOTAL){
+                tst_resm(TFAIL, "get unnecessary event: "
+                    "wd=%d mask=%x cookie=%u len=%u"
+                    "name=\"%s\"",event->wd, event->mask,
+                    event->cookie, event->len, 
+                            event->name);
+
+            } else     if ((event_set[test_num].mask == event->mask) &&
+                    (! strncmp( event_set[test_num].name,
+                        event->name, event->len))) {
+                tst_resm(TPASS, "get event: wd=%d mask=%x" 
+                        " cookie=%u len=%u name=\"%s\"",
+                        event->wd, event->mask,
+                        event->cookie, event->len, 
+                        event->name);
+
+            } else {
+                tst_resm(TFAIL, "get event: wd=%d mask=%x "
+                    "(expected %x) cookie=%u len=%u "
+                    "name=\"%s\" (expected \"%s\") %d",
+                    event->wd, event->mask,    
+                    event_set[test_num].mask,
+                    event->cookie, event->len, event->name,
+                    event_set[test_num].name, 
+                    strcmp(event_set[test_num].name, 
+                        event->name));
+            }
+            test_num++;
+            i += EVENT_SIZE + event->len;
+        }
+
+        for (; test_num<TST_TOTAL; test_num++){
+            tst_resm(TFAIL, "don't get event: mask=%x ",
+                    event_set[test_num]);
+
+        }
+
+    }    /* End for TEST_LOOPING */
+
+    /*
+     * cleanup and exit
+     */
+    cleanup();
+
+    return 0;
+}    /* End main */
+
+/*
+ * setup() - performs all ONE TIME setup for this test.
+ */
+void setup(){
+    /* capture signals */
+    tst_sig(NOFORK, DEF_HANDLER, cleanup);
+
+    /* Pause if that option was specified */
+    TEST_PAUSE;
+
+    /* make a temp directory and cd to it */
+    tst_tmpdir();
+
+    if ((fd_notify = inotify_init ()) < 0) {
+        if( errno == ENOSYS ){
+            tst_resm(TCONF, "inotify is not configured in this kernel.");
+            tst_resm(TCONF, "Test will not run.");
+            tst_exit();
+        }else{
+            tst_brkm(TBROK, cleanup,
+                "inotify_init () Failed, errno=%d : %s",
+                errno, strerror(errno));
+        }
+    }
+
+    if ((wd = inotify_add_watch (fd_notify, ".", IN_ALL_EVENTS)) < 0){
+        tst_brkm(TBROK, cleanup,
+                "inotify_add_watch (%d, \".\", IN_ALL_EVENTS)" 
+                "Failed, errno=%d : %s",
+                fd_notify, errno, strerror(errno));
+    };
+
+}    /* End setup() */
+
+
+/*
+ * cleanup() - performs all ONE TIME cleanup for this test at
+ *        completion or premature exit.
+ */
+void cleanup(){
+    if (inotify_rm_watch(fd_notify, wd) < 0) {
+        tst_resm(TWARN,    "inotify_rm_watch (%d, %d) Failed,"
+                "errno=%d : %s",
+                fd_notify, wd, errno, strerror(errno));
+
+    }
+
+    if (close(fd_notify) == -1) {
+        tst_resm(TWARN, "close(%d) Failed, errno=%d : %s", 
+                fd_notify, errno, strerror(errno));
+    }
+
+
+    /*
+     * print timing stats if that option was specified.
+     * print errno log if that option was specified.
+     */
+    TEST_CLEANUP;
+
+    /* Remove tmp dir and all files in it */
+    tst_rmdir();
+
+    /* exit with return code appropriate for results */
+    tst_exit();
+}    /* End cleanup() */
diff -uprN ltp.old/testcases/kernel/syscalls/inotify/Makefile ltp/testcases/kernel/syscalls/inotify/Makefile
--- ltp.old/testcases/kernel/syscalls/inotify/Makefile	1970-01-01 03:00:00.000000000 +0300
+++ ltp/testcases/kernel/syscalls/inotify/Makefile	2007-05-22 17:23:30.000000000 +0400
@@ -0,0 +1,31 @@
+#
+#  Copyright (c) SWSoft, 2007
+#
+#  This program is free software;  you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY;  without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+#  the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program;  if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+CFLAGS += -I../../../../include -Wall --static
+LDLIBS += -L../../../../lib -lltp
+
+SRCS    = $(wildcard *.c)
+TARGETS = $(patsubst %.c,%,$(SRCS))
+
+all: $(TARGETS)
+
+install:
+	@set -e; for i in $(TARGETS); do ln -f $$i ../../../bin/$$i ; done
+
+clean:
+	rm -f $(TARGETS)
diff -uprN ltp.old/testcases/kernel/syscalls/inotify/README ltp/testcases/kernel/syscalls/inotify/README
--- ltp.old/testcases/kernel/syscalls/inotify/README	1970-01-01 03:00:00.000000000 +0300
+++ ltp/testcases/kernel/syscalls/inotify/README	2007-05-24 18:31:15.000000000 +0400
@@ -0,0 +1,36 @@
+This contains two tests for the inotify subsytem.
+
+The  inotify  API  provides  a mechanism for monitoring file system events.  
+Inotify can be used to monitor individual files, or to monitor directories.  
+When a directory is monitored, inotify will return events for the directory 
+itself, and for files inside  the directory.
+
+The tests are intended to do the following:
+test 1:
+	initialize inotify for the test file
+	generate sequence events:
+		operation			expected event
+		-----------------------------------------
+		chmod file			IN_ATTRIB
+		open read-only			IN_OPEN
+		read				IN_ACCESS
+		close				IN_CLOSE_NOWRITE
+		open read-write			IN_OPEN
+		write				IN_MODIFY
+		close				IN_CLOSE_WRITE
+	check that all events have been received
+test 2:
+	initialize inotify for the test directory
+	generate sequence events:
+		operate				expected event
+		-----------------------------------------
+		chmod				IN_ISDIR | IN_ATTRIB
+		creat file			IN_CREATE
+						IN_OPEN
+		close				IN_CLOSE_WRITE
+		rename file			IN_MOVED_FROM
+						IN_MOVED_TO
+		unlink file			IN_DELETE
+		rename yourself			IN_MOVE_SELF
+		rename back			IN_MOVE_SELF
+	check that all events have been received