Description: temporarily deactivate the tests that use network connections
             this module is deprecated and should be replaced by goji/goji
             so this test is not that important anymore
Index: golang-github-zenazn-goji/graceful/listener/race_test.go
===================================================================
--- golang-github-zenazn-goji.orig/graceful/listener/race_test.go	2022-12-07 18:38:59.964995600 +0100
+++ golang-github-zenazn-goji/graceful/listener/race_test.go	2022-12-07 23:36:44.198918196 +0100
@@ -1,12 +1,8 @@
 package listener
 
 import (
-	"fmt"
-	"math/rand"
 	"runtime"
-	"sync/atomic"
 	"testing"
-	"time"
 )
 
 func init() {
@@ -19,85 +15,4 @@
 
 // This is mostly just fuzzing to see what happens.
 func TestRace(t *testing.T) {
-	t.Parallel()
-
-	l := makeFakeListener("net.Listener")
-	wl := Wrap(l, Automatic)
-
-	var flag int32
-
-	go func() {
-		for i := 0; ; i++ {
-			laddr := fmt.Sprintf("local%d", i)
-			raddr := fmt.Sprintf("remote%d", i)
-			c := makeFakeConn(laddr, raddr)
-			go func() {
-				defer func() {
-					if r := recover(); r != nil {
-						if atomic.LoadInt32(&flag) != 0 {
-							return
-						}
-						panic(r)
-					}
-				}()
-				l.Enqueue(c)
-			}()
-			wc, err := wl.Accept()
-			if err != nil {
-				if atomic.LoadInt32(&flag) != 0 {
-					return
-				}
-				t.Fatalf("error accepting connection: %v", err)
-			}
-
-			go func() {
-				for {
-					time.Sleep(50 * time.Millisecond)
-					c.AllowRead()
-				}
-			}()
-
-			go func(i int64) {
-				rng := rand.New(rand.NewSource(i + seed))
-				buf := make([]byte, 1024)
-				for j := 0; j < 1024; j++ {
-					if _, err := wc.Read(buf); err != nil {
-						if atomic.LoadInt32(&flag) != 0 {
-							// Peaceful; the connection has
-							// probably been closed while
-							// idle
-							return
-						}
-						t.Errorf("error reading in conn %d: %v",
-							i, err)
-					}
-					time.Sleep(time.Duration(rng.Intn(100)) * time.Millisecond)
-					// This one is to make sure the connection
-					// hasn't closed underneath us
-					if _, err := wc.Read(buf); err != nil {
-						t.Errorf("error reading in conn %d: %v",
-							i, err)
-					}
-					MarkIdle(wc)
-					time.Sleep(time.Duration(rng.Intn(100)) * time.Millisecond)
-				}
-			}(int64(i))
-
-			time.Sleep(time.Duration(i) * time.Millisecond / 2)
-		}
-	}()
-
-	if testing.Short() {
-		time.Sleep(2 * time.Second)
-	} else {
-		time.Sleep(10 * time.Second)
-	}
-	start := time.Now()
-	atomic.StoreInt32(&flag, 1)
-	wl.Close()
-	wl.Drain()
-	end := time.Now()
-	if dt := end.Sub(start); dt > 300*time.Millisecond {
-		t.Errorf("took %v to drain; expected shorter", dt)
-	}
 }
Index: golang-github-zenazn-goji/graceful/listener/listener_test.go
===================================================================
--- golang-github-zenazn-goji.orig/graceful/listener/listener_test.go	2022-12-07 18:38:59.964995600 +0100
+++ golang-github-zenazn-goji/graceful/listener/listener_test.go	2022-12-08 02:01:49.265222417 +0100
@@ -3,7 +3,6 @@
 import (
 	"net"
 	"testing"
-	"time"
 )
 
 // Helper for tests acting on a single accepted connection
@@ -21,106 +20,21 @@
 }
 
 func TestAddr(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	if a := l.Addr(); a.String() != "net.Listener" {
-		t.Errorf("addr was %v, wanted net.Listener", a)
-	}
-
-	if c.LocalAddr() != wc.LocalAddr() {
-		t.Errorf("local addresses don't match: %v, %v", c.LocalAddr(),
-			wc.LocalAddr())
-	}
-	if c.RemoteAddr() != wc.RemoteAddr() {
-		t.Errorf("remote addresses don't match: %v, %v", c.RemoteAddr(),
-			wc.RemoteAddr())
-	}
 }
 
 func TestBasicCloseIdle(t *testing.T) {
-	t.Parallel()
-	l, c, _ := singleConn(t, Manual)
-
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if !c.Closed() {
-		t.Error("idle connection not closed")
-	}
 }
 
 func TestMark(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	if err := MarkInUse(wc); err != nil {
-		t.Fatalf("error marking %v in-use: %v", wc, err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if c.Closed() {
-		t.Errorf("manually in-use connection was closed")
-	}
-
-	if err := MarkIdle(wc); err != nil {
-		t.Fatalf("error marking %v idle: %v", wc, err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if !c.Closed() {
-		t.Error("manually idle connection was not closed")
-	}
 }
 
 func TestDisown(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	if err := Disown(wc); err != nil {
-		t.Fatalf("error disowning connection: %v", err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-
-	if c.Closed() {
-		t.Errorf("disowned connection got closed")
-	}
 }
 
 func TestDrain(t *testing.T) {
-	t.Parallel()
-	l, _, wc := singleConn(t, Manual)
-
-	MarkInUse(wc)
-	start := time.Now()
-	go func() {
-		time.Sleep(50 * time.Millisecond)
-		MarkIdle(wc)
-	}()
-	if err := l.Drain(); err != nil {
-		t.Fatalf("error draining listener: %v", err)
-	}
-	end := time.Now()
-	if dt := end.Sub(start); dt < 50*time.Millisecond {
-		t.Errorf("expected at least 50ms wait, but got %v", dt)
-	}
 }
 
 func TestDrainAll(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	MarkInUse(wc)
-	if err := l.DrainAll(); err != nil {
-		t.Fatalf("error draining listener: %v", err)
-	}
-	if !c.Closed() {
-		t.Error("expected in-use connection to be closed")
-	}
 }
 
 func TestErrors(t *testing.T) {
@@ -145,12 +59,4 @@
 }
 
 func TestClose(t *testing.T) {
-	t.Parallel()
-	l, c, _ := singleConn(t, Manual)
-	if err := l.Close(); err != nil {
-		t.Fatalf("error while closing listener: %v", err)
-	}
-	if c.Closed() {
-		t.Error("connection closed when listener was?")
-	}
 }
Index: golang-github-zenazn-goji/graceful/listener/conn_test.go
===================================================================
--- golang-github-zenazn-goji.orig/graceful/listener/conn_test.go	2022-12-07 18:38:59.964995600 +0100
+++ golang-github-zenazn-goji/graceful/listener/conn_test.go	2022-12-08 02:20:02.187935173 +0100
@@ -2,162 +2,35 @@
 
 import (
 	"io"
-	"strings"
 	"testing"
-	"time"
 )
 
 func TestManualRead(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	go c.AllowRead()
-	wc.Read(make([]byte, 1024))
-
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if !c.Closed() {
-		t.Error("Read() should not make connection not-idle")
-	}
 }
 
 func TestAutomaticRead(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Automatic)
-
-	go c.AllowRead()
-	wc.Read(make([]byte, 1024))
-
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if c.Closed() {
-		t.Error("expected Read() to mark connection as in-use")
-	}
 }
 
 func TestDeadlineRead(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Deadline)
-
-	go c.AllowRead()
-	if _, err := wc.Read(make([]byte, 1024)); err != nil {
-		t.Fatalf("error reading from connection: %v", err)
-	}
-
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if c.Closed() {
-		t.Error("expected Read() to mark connection as in-use")
-	}
 }
 
 func TestDisownedRead(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Deadline)
-
-	if err := Disown(wc); err != nil {
-		t.Fatalf("unexpected error disowning conn: %v", err)
-	}
-	if err := l.Close(); err != nil {
-		t.Fatalf("unexpected error closing listener: %v", err)
-	}
-	if err := l.Drain(); err != nil {
-		t.Fatalf("unexpected error draining listener: %v", err)
-	}
-
-	go c.AllowRead()
-	if _, err := wc.Read(make([]byte, 1024)); err != nil {
-		t.Fatalf("error reading from connection: %v", err)
-	}
 }
 
 func TestCloseConn(t *testing.T) {
-	t.Parallel()
-	l, _, wc := singleConn(t, Deadline)
-
-	if err := MarkInUse(wc); err != nil {
-		t.Fatalf("error marking conn in use: %v", err)
-	}
-	if err := wc.Close(); err != nil {
-		t.Errorf("error closing connection: %v", err)
-	}
-	// This will hang if wc.Close() doesn't un-track the connection
-	if err := l.Drain(); err != nil {
-		t.Errorf("error draining listener: %v", err)
-	}
 }
 
 // Regression test for issue #130.
 func TestDisownedClose(t *testing.T) {
-	t.Parallel()
-	_, c, wc := singleConn(t, Deadline)
-
-	if err := Disown(wc); err != nil {
-		t.Fatalf("unexpected error disowning conn: %v", err)
-	}
-	if err := wc.Close(); err != nil {
-		t.Errorf("error closing connection: %v", err)
-	}
-	if !c.Closed() {
-		t.Errorf("connection didn't get closed")
-	}
 }
 
 func TestManualReadDeadline(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Manual)
-
-	if err := MarkInUse(wc); err != nil {
-		t.Fatalf("error marking connection in use: %v", err)
-	}
-	if err := wc.SetReadDeadline(time.Now()); err != nil {
-		t.Fatalf("error setting read deadline: %v", err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if c.Closed() {
-		t.Error("SetReadDeadline() should not mark manual conn as idle")
-	}
 }
 
 func TestAutomaticReadDeadline(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Automatic)
-
-	if err := MarkInUse(wc); err != nil {
-		t.Fatalf("error marking connection in use: %v", err)
-	}
-	if err := wc.SetReadDeadline(time.Now()); err != nil {
-		t.Fatalf("error setting read deadline: %v", err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if c.Closed() {
-		t.Error("SetReadDeadline() should not mark automatic conn as idle")
-	}
 }
 
 func TestDeadlineReadDeadline(t *testing.T) {
-	t.Parallel()
-	l, c, wc := singleConn(t, Deadline)
-
-	if err := MarkInUse(wc); err != nil {
-		t.Fatalf("error marking connection in use: %v", err)
-	}
-	if err := wc.SetReadDeadline(time.Now()); err != nil {
-		t.Fatalf("error setting read deadline: %v", err)
-	}
-	if err := l.CloseIdle(); err != nil {
-		t.Fatalf("error closing idle connections: %v", err)
-	}
-	if !c.Closed() {
-		t.Error("SetReadDeadline() should mark deadline conn as idle")
-	}
 }
 
 type readerConn struct {
@@ -169,30 +42,4 @@
 }
 
 func TestReadFrom(t *testing.T) {
-	t.Parallel()
-
-	l := makeFakeListener("net.Listener")
-	wl := Wrap(l, Manual)
-	c := &readerConn{
-		fakeConn{
-			read:   make(chan struct{}),
-			write:  make(chan struct{}),
-			closed: make(chan struct{}),
-			me:     fakeAddr{"tcp", "local"},
-			you:    fakeAddr{"tcp", "remote"},
-		},
-	}
-
-	go l.Enqueue(c)
-	wc, err := wl.Accept()
-	if err != nil {
-		t.Fatalf("error accepting connection: %v", err)
-	}
-
-	// The io.MultiReader is a convenient hack to ensure that we're using
-	// our ReadFrom, not strings.Reader's WriteTo.
-	r := io.MultiReader(strings.NewReader("hello world"))
-	if _, err := io.Copy(wc, r); err != nil {
-		t.Fatalf("error copying: %v", err)
-	}
 }