Subversion Repositories openrisc

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build linux

package inotify

import (
        "os"
        "testing"
        "time"
)

func TestInotifyEvents(t *testing.T) {
        // Create an inotify watcher instance and initialize it
        watcher, err := NewWatcher()
        if err != nil {
                t.Fatalf("NewWatcher() failed: %s", err)
        }

        t.Logf("NEEDS TO BE CONVERTED TO NEW GO TOOL") // TODO
        return

        // Add a watch for "_test"
        err = watcher.Watch("_test")
        if err != nil {
                t.Fatalf("Watcher.Watch() failed: %s", err)
        }

        // Receive errors on the error channel on a separate goroutine
        go func() {
                for err := range watcher.Error {
                        t.Fatalf("error received: %s", err)
                }
        }()

        const testFile string = "_test/TestInotifyEvents.testfile"

        // Receive events on the event channel on a separate goroutine
        eventstream := watcher.Event
        var eventsReceived = 0
        done := make(chan bool)
        go func() {
                for event := range eventstream {
                        // Only count relevant events
                        if event.Name == testFile {
                                eventsReceived++
                                t.Logf("event received: %s", event)
                        } else {
                                t.Logf("unexpected event received: %s", event)
                        }
                }
                done <- true
        }()

        // Create a file
        // This should add at least one event to the inotify event queue
        _, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
        if err != nil {
                t.Fatalf("creating test file failed: %s", err)
        }

        // We expect this event to be received almost immediately, but let's wait 1 s to be sure
        time.Sleep(1 * time.Second)
        if eventsReceived == 0 {
                t.Fatal("inotify event hasn't been received after 1 second")
        }

        // Try closing the inotify instance
        t.Log("calling Close()")
        watcher.Close()
        t.Log("waiting for the event channel to become closed...")
        select {
        case <-done:
                t.Log("event channel closed")
        case <-time.After(1 * time.Second):
                t.Fatal("event stream was not closed after 1 second")
        }
}

func TestInotifyClose(t *testing.T) {
        watcher, _ := NewWatcher()
        watcher.Close()

        done := make(chan bool)
        go func() {
                watcher.Close()
                done <- true
        }()

        select {
        case <-done:
        case <-time.After(50 * time.Millisecond):
                t.Fatal("double Close() test failed: second Close() call didn't return")
        }

        err := watcher.Watch("_test")
        if err == nil {
                t.Fatal("expected error on Watch() after Close(), got nil")
        }
}