package main

import (
	"fmt"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"strconv"
	"sync"
)

func main() {
	fmt.Println("Starting test")
	for i := 0; i < 10000; i++ {
		fmt.Println("Loop", i)

		// Start the server
		client := &http.Client{}
		closeAndWait := RunServer(i)

		// Run parellel requests and wait for them to finish
		ParallelRequets(client, i)

		// Close the server and wait for Serve to return
		closeAndWait()
	}
	fmt.Println("Test Pass")
}

func ParallelRequets(client *http.Client, expected int) {
	var wait sync.WaitGroup
	for minor := 0; minor < 2; minor++ {
		wait.Add(1)
		go func() {
			defer wait.Done()
			resp, err := client.Get("http://127.0.0.1:8081")
			if err != nil {
				fmt.Println("Get error!", err)
				return
			}
			defer resp.Body.Close()

			data, err := ioutil.ReadAll(resp.Body)
			actual, err := strconv.Atoi(string(data))

			if expected != actual {
				fmt.Printf("Mismatch! expected %v got %v\n", expected, actual)
				os.Exit(-1)
			}

		}()
	}
	wait.Wait()
}

func RunServer(major int) func() {
	fmt.Println("Starting", major)

	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "%v", major)
	})
	server := http.Server{Handler: handler}
	listener, err := net.Listen("tcp", ":8081")
	if err != nil {
		panic("Listen error!")
	}
	done := make(chan bool, 1)

	go func() {
		err := server.Serve(listener)
		if err != http.ErrServerClosed {
			fmt.Println("Unexpected server error", err)
		}
		done <- true
	}()

	return func() {
		server.Close()
		<-done
		fmt.Println("Terminated", major)
	}
}

$ go run .
Starting test
Loop 0
Starting 0
Terminated 0
Loop 1
Starting 1
Terminated 1
...
Loop 9999
Starting 9999
Terminated 9999
Test Pass

$ go run .
Starting test
Loop 0
Starting 0
Terminated 0
Loop 1
Starting 1
Terminated 1
...
Starting 795
Terminated 795
Loop 796
Starting 796
Terminated 796
Loop 797
Starting 797
Mismatch! expected 797 got 796
exit status 255