fixed tests

net/swarm/simul_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 func TestSimultOpen(t *testing.T) {
-	t.Skip("skipping for another test")
+	// t.Skip("skipping for another test")
 
 	addrs := []string{
 		"/ip4/127.0.0.1/tcp/1244",
@@ -51,8 +51,9 @@ func TestSimultOpen(t *testing.T) {
 func TestSimultOpenMany(t *testing.T) {
 	t.Skip("laggy")
 
+	many := 500
 	addrs := []string{}
-	for i := 2200; i < 2300; i++ {
+	for i := 2200; i < (2200 + many); i++ {
 		s := fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", i)
 		addrs = append(addrs, s)
 	}

net/swarm/swarm_test.go

@@ -164,6 +164,7 @@ func SubtestSwarm(t *testing.T, addrs []string, MsgNum int) {
 }
 
 func TestSwarm(t *testing.T) {
+	// t.Skip("skipping for another test")
 
 	addrs := []string{
 		"/ip4/127.0.0.1/tcp/1234",
@@ -173,5 +174,6 @@ func TestSwarm(t *testing.T) {
 		"/ip4/127.0.0.1/tcp/1238",
 	}
 
-	SubtestSwarm(t, addrs, 1000)
+	msgs := 100
+	SubtestSwarm(t, addrs, msgs)
 }

routing/dht/dht_test.go

@@ -112,13 +112,13 @@ func TestPing(t *testing.T) {
 	}
 
 	//Test that we can ping the node
-	ctxT, _ := context.WithTimeout(ctx, 5*time.Millisecond)
+	ctxT, _ := context.WithTimeout(ctx, 100*time.Millisecond)
 	err = dhtA.Ping(ctxT, peerB)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	ctxT, _ = context.WithTimeout(ctx, 5*time.Millisecond)
+	ctxT, _ = context.WithTimeout(ctx, 100*time.Millisecond)
 	err = dhtB.Ping(ctxT, peerA)
 	if err != nil {
 		t.Fatal(err)
@@ -396,53 +396,61 @@ func TestFindPeer(t *testing.T) {
 func TestConnectCollision(t *testing.T) {
 	// t.Skip("skipping test to debug another")
 
-	ctx := context.Background()
-	u.Debug = false
-	addrA, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1235")
-	if err != nil {
-		t.Fatal(err)
-	}
-	addrB, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/5679")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	peerA := makePeer(addrA)
-	peerB := makePeer(addrB)
-
-	dhtA := setupDHT(ctx, t, peerA)
-	dhtB := setupDHT(ctx, t, peerB)
+	runTimes := 100
 
-	defer dhtA.Halt()
-	defer dhtB.Halt()
-	defer dhtA.network.Close()
-	defer dhtB.network.Close()
+	for rtime := 0; rtime < runTimes; rtime++ {
+		log.Notice("Running Time: ", rtime)
 
-	done := make(chan struct{})
-	go func() {
-		_, err = dhtA.Connect(ctx, peerB)
+		ctx := context.Background()
+		u.Debug = false
+		addrA, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1235")
 		if err != nil {
 			t.Fatal(err)
 		}
-		done <- struct{}{}
-	}()
-	go func() {
-		_, err = dhtB.Connect(ctx, peerA)
+		addrB, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/5679")
 		if err != nil {
 			t.Fatal(err)
 		}
-		done <- struct{}{}
-	}()
 
-	timeout := time.After(time.Second * 5)
-	select {
-	case <-done:
-	case <-timeout:
-		t.Fatal("Timeout received!")
-	}
-	select {
-	case <-done:
-	case <-timeout:
-		t.Fatal("Timeout received!")
+		peerA := makePeer(addrA)
+		peerB := makePeer(addrB)
+
+		dhtA := setupDHT(ctx, t, peerA)
+		dhtB := setupDHT(ctx, t, peerB)
+
+		defer dhtA.Halt()
+		defer dhtB.Halt()
+		defer dhtA.network.Close()
+		defer dhtB.network.Close()
+
+		done := make(chan struct{})
+		go func() {
+			_, err = dhtA.Connect(ctx, peerB)
+			if err != nil {
+				t.Fatal(err)
+			}
+			done <- struct{}{}
+		}()
+		go func() {
+			_, err = dhtB.Connect(ctx, peerA)
+			if err != nil {
+				t.Fatal(err)
+			}
+			done <- struct{}{}
+		}()
+
+		timeout := time.After(time.Second)
+		select {
+		case <-done:
+		case <-timeout:
+			t.Fatal("Timeout received!")
+		}
+		select {
+		case <-done:
+		case <-timeout:
+			t.Fatal("Timeout received!")
+		}
+
+		<-time.After(100 * time.Millisecond)
 	}
 }