Speed test

client.js

var timerFunc;
if(window.performance) {
	timerFunc = performance.now.bind(performance);
} else {
	timerFunc = Date.now.bind(Date);
}

if(window.xhr) { xhr.abort(); }
xhr = new XMLHttpRequest();
xhr.responseType = "blob";
xhr.addEventListener("progress", function(ev) {
	if(ev.lengthComputable) {
		console.log("Transfer progress:", Math.floor(ev.loaded/ev.total*100)+"%");
	}
});
xhr.addEventListener("load", function(ev) {
	var finishTime = timerFunc();

	var totalTime = finishTime-startTime;
	var bytesPerSec = ev.total/(totalTime/1000);
	var bitsPerSec = bytesPerSec*8;

	console.info("Transfer time:", Math.round(totalTime)+"ms")
	console.info("Transfer rate:", Math.round(bitsPerSec)+"bps")
});

var size = 104857600; // 100MiB

xhr.open("get", "/download?b="+size);

var startTime = timerFunc();
xhr.send();

server.go

package main

import (
	"io"
	"net/http"
	"strconv"
)

func handleDownload(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()
	b, err := strconv.ParseInt(q.Get("b"), 10, 64)
	if err != nil {
		sendStringErr(w, http.StatusBadRequest, "b must be an integer\n")
		return
	}
	if b <= 0 {
		sendStringErr(w, http.StatusBadRequest, "b must be greater than 0\n")
		return
	}

	h := w.Header()
	h.Set("Content-Length", strconv.FormatInt(b, 10))
	h.Set("Content-Type", "application/octet-stream")
	w.WriteHeader(http.StatusOK)

	io.Copy(w, devZero{Size: b})
}

func main() {
	http.HandleFunc("/download", handleDownload)

	http.ListenAndServe(":1234", nil)
}

func sendStringErr(w http.ResponseWriter, code int, err string) {
	h := w.Header()
	h.Set("Content-Type", "text/plain")
	h.Set("Content-Length", strconv.Itoa(len(err)))
	w.WriteHeader(code)
	io.WriteString(w, err)
}

type devZero struct {
	pos  int64
	Size int64
}

func (d devZero) Read(b []byte) (n int, err error) {
	if d.pos >= d.Size {
		return 0, io.EOF
	}

	n = len(b)
	if d.Size < d.pos+int64(n) {
		n = int(d.Size - d.pos)
	}

	for i := range b[:n] {
		b[i] = 0
	}

	d.pos += int64(n)

	return
}

func (d devZero) WriteTo(w io.Writer) (n int64, err error) {
	if d.pos >= d.Size {
		return 0, io.EOF
	}

	b := make([]byte, d.Size-d.pos)

	writeSize := 0
	for {
		writeSize, err = w.Write(b)
		n += int64(writeSize)
		if err != nil {
			return
		}

		b = b[writeSize:]
		if len(b) == 0 {
			return
		}
	}
}