st.MakeNode().Name("node-b").Label("zone", "zone1").Label(v1.LabelHostname, "node-b").Obj(),
				st.MakeNode().Name("node-x").Label("zone", "zone2").Label(v1.LabelHostname, "node-x").Obj(),
			},
			failedNodes: []*v1.Node{
				st.MakeNode().Name("node-y").Label("zone", "zone2").Label(v1.LabelHostname, "node-y").Obj(),
			},
			want: []framework.NodeScore{
				{Name: "node-a", Score: 75},
				{Name: "node-b", Score: 75},

}
func testResponseControllerSetPastReadDeadline(t *testing.T, mode testMode) {
	readc := make(chan struct{})
	donec := make(chan struct{})
	cst := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) {
		defer close(donec)
		ctl := NewResponseController(w)
		b := make([]byte, 3)
		n, err := io.ReadFull(r.Body, b)
		b = b[:n]
		if err != nil || string(b) != "one" {

			},
			want: &preFilterState{
				Constraints:       []topologySpreadConstraint{zoneConstraint},
				TpKeyToDomainsNum: map[string]int{"zone": 2},
				TpKeyToCriticalPaths: map[string]*criticalPaths{
					"zone": {{"zone1", 1}, {"zone2", 2}},
				},
				TpPairToMatchNum: map[topologyPair]int{
					{key: "zone", value: "zone1"}: 1,
					{key: "zone", value: "zone2"}: 2,

		runtime.Gosched()
		x = 1
		wg.Done()
		c <- true
	}()
	go func() {
		wg.Add(1)
		runtime.Gosched()
		x = 2
		wg.Done()
		c <- true
	}()
	wg.Wait()
	<-c
	<-c
}

func TestRaceWaitGroupWrongAdd(t *testing.T) {
	c := make(chan bool, 2)
	var wg sync.WaitGroup
	go func() {
		wg.Add(1)
		time.Sleep(100 * time.Millisecond)
		wg.Done()
		c <- true
	}()
	go func() {

			b.current = next
		}
		b.current = body
		b.typeCaseBody(cc, done)
		b.current = next
	}
	if default_ != nil {
		b.typeCaseBody(default_, done)
	} else {
		b.jump(done)
	}
	b.current = done
}

func (b *builder) typeCaseBody(cc *ast.CaseClause, done *Block) {
	b.targets = &targets{
		tail:   b.targets,
		_break: done,
	}
	b.stmtList(cc.Body)
	b.targets = b.targets.tail

func main1(t *testing.T) {
	const N = 100000
	done := make(chan bool, 2)
	b := make([]byte, 2)
	go func() {
		for i := 0; i < N; i++ {
			b[0] = byte(i)
			b[1] = byte(i)
		}
		done <- true
	}()
	go func() {
		for i := 0; i < N; i++ {
			x, y := read1(b)
			if byte(x) != byte(y) {
				t.Errorf("x=%x y=%x\n", x, y)
				done <- false
				return
			}
		}
		done <- true
	}()
	<-done
	<-done
}

	c1 := make(chan int, 1)
	c2 := make(chan int, 1)
	const procs = 2
	var done sync.WaitGroup
	done.Add(4 * procs)
	for p := 0; p < procs; p++ {
		const iters = 1e3
		go func() {
			trace.WithRegion(context.Background(), "special", func() {
				for i := 0; i < iters; i++ {
					runtime.Gosched()
					c0 <- 0
				}
				done.Done()
			})
		}()
		go func() {

	_ = v1 + v2
	c := make(chan int, 1)
	done := make(chan bool)
	go func() {
		defer func() {
			recover()
		}()
		v1 = 1
		c <- 1
		done <- true
	}()
	go func() {
		time.Sleep(1e7)
		v2 = 2
		close(c)
		done <- true
	}()
	time.Sleep(2e7)
	if _, who := <-c; who {
		v2 = 2
	} else {
		v1 = 2
	}
	<-done
	<-done
}

        crawlerStatsHelper.done(key);
        logger.info(localLogMsg.get());
        String[] values = localLogMsg.get().split("\t");
        assertEquals(3, values.length);
        assertEquals("url:test", values[0]);
        assertTrue(values[1].startsWith("time:"));
        assertTrue(values[2].startsWith("done:"));

        localLogMsg.remove();
        crawlerStatsHelper.done(key);
        assertNull(localLogMsg.get());

	c1 := make(chan int)
	c2 := make(chan int)
	c3 := make(chan int)
	c4 := make(chan int)
	done := make(chan bool)
	cmux := make(chan int)
	go sender(*iterations, c1, c2, c3, c4)
	go mux(cmux, c1, done)
	go mux(cmux, c2, done)
	go mux(cmux, c3, done)
	go mux(cmux, c4, done)
	go func() {
		<-done
		<-done
		<-done
		<-done
		close(cmux)
	}()
	// We keep the recver because it might catch more bugs in the future.