Subversion Repositories openrisc

// Copyright 2011 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.
package sync_test

import (
        . "sync"
        "testing"
)

func TestCondSignal(t *testing.T) {
        var m Mutex
        c := NewCond(&m)
        n := 2
        running := make(chan bool, n)
        awake := make(chan bool, n)
        for i := 0; i < n; i++ {
                go func() {
                        m.Lock()
                        running <- true
                        c.Wait()
                        awake <- true
                        m.Unlock()
                }()
        }
        for i := 0; i < n; i++ {
                <-running // Wait for everyone to run.
        }
        for n > 0 {
                select {
                case <-awake:
                        t.Fatal("goroutine not asleep")
                default:
                }
                m.Lock()
                c.Signal()
                m.Unlock()
                <-awake // Will deadlock if no goroutine wakes up
                select {
                case <-awake:
                        t.Fatal("too many goroutines awake")
                default:
                }
                n--
        }
        c.Signal()
}

func TestCondSignalGenerations(t *testing.T) {
        var m Mutex
        c := NewCond(&m)
        n := 100
        running := make(chan bool, n)
        awake := make(chan int, n)
        for i := 0; i < n; i++ {
                go func(i int) {
                        m.Lock()
                        running <- true
                        c.Wait()
                        awake <- i
                        m.Unlock()
                }(i)
                if i > 0 {
                        a := <-awake
                        if a != i-1 {
                                t.Fatalf("wrong goroutine woke up: want %d, got %d", i-1, a)
                        }
                }
                <-running
                m.Lock()
                c.Signal()
                m.Unlock()
        }
}

func TestCondBroadcast(t *testing.T) {
        var m Mutex
        c := NewCond(&m)
        n := 200
        running := make(chan int, n)
        awake := make(chan int, n)
        exit := false
        for i := 0; i < n; i++ {
                go func(g int) {
                        m.Lock()
                        for !exit {
                                running <- g
                                c.Wait()
                                awake <- g
                        }
                        m.Unlock()
                }(i)
        }
        for i := 0; i < n; i++ {
                for i := 0; i < n; i++ {
                        <-running // Will deadlock unless n are running.
                }
                if i == n-1 {
                        m.Lock()
                        exit = true
                        m.Unlock()
                }
                select {
                case <-awake:
                        t.Fatal("goroutine not asleep")
                default:
                }
                m.Lock()
                c.Broadcast()
                m.Unlock()
                seen := make([]bool, n)
                for i := 0; i < n; i++ {
                        g := <-awake
                        if seen[g] {
                                t.Fatal("goroutine woke up twice")
                        }
                        seen[g] = true
                }
        }
        select {
        case <-running:
                t.Fatal("goroutine did not exit")
        default:
        }
        c.Broadcast()
}