package net_test

import (
        "fmt"
        "math/rand"
        "net"
        "sync"
        "testing"
)

const (
        ndialers = 100
        nlisteners = 100
        nconn = 100000
)

func TestAccept(t *testing.T) {
        listeners := []net.Listener{}
        l, err := net.ListenTCP("tcp", &net.TCPAddr{})
        if err != nil {
                panic("Listen failed: " + err.Error())
        }
        listeners = append(listeners, l)

        // start dialers
        var dialWg sync.WaitGroup
        for k := 0; k < ndialers; k++ {
                dialWg.Add(1)
                go func() {
                        rng := rand.New(rand.NewSource(int64(k)))
                        defer dialWg.Done()
                        for j := 0; j < nconn; j++ {
                                l := listeners[rng.Intn(len(listeners))]
                                fmt.Printf("Dialing %v\n", l.Addr())
                                c, err := net.Dial("tcp", l.Addr().String())
                                if err != nil {
                                        panic("Dial failed: " + err.Error())
                                }
                                tc := c.(*net.TCPConn)
                                if err := tc.SetLinger(0); err != nil {
                                        panic(err)
                                }
                                if err := c.Close(); err != nil {
                                        panic(err)
                                }
                        }
                }()
        }

        // accept on listeners
        var listenWg sync.WaitGroup
        for _, listener := range listeners {
                listenWg.Add(1)
                l := listener
                go func() {
                        defer listenWg.Done()
                        for {
                                fmt.Printf("Accepting on %v\n", l.Addr())
                                c, err := l.Accept()
                                if err != nil {
                                        break
                                }
                                tc := c.(*net.TCPConn)
                                if err := tc.SetLinger(0); err != nil {
                                        panic(err)
                                }
                                if err := c.Close(); err != nil {
                                        panic(err)
                                }
                        }
                }()
        }

        dialWg.Wait()

        for _, l := range listeners {
                if err := l.Close(); err != nil {
                        panic("listener close failed: " + err.Error())
                }
        }

        listenWg.Wait()
}