diff --git a/auth_test.go b/auth_test.go
new file mode 100644
index 00000000..d9b4f4d4
--- /dev/null
+++ b/auth_test.go
@@ -0,0 +1,57 @@
+package gin
+
+import (
+	"encoding/base64"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestBasicAuthSucceed(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/login", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	accounts := Accounts{"admin": "password"}
+	r.Use(BasicAuth(accounts))
+
+	r.GET("/login", func(c *Context) {
+		c.String(200, "autorized")
+	})
+
+	req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password")))
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+	bodyAsString := w.Body.String()
+
+	if bodyAsString != "autorized" {
+		t.Errorf("Response body should be `autorized`, was  %s", bodyAsString)
+	}
+}
+
+func TestBasicAuth401(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/login", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	accounts := Accounts{"foo": "bar"}
+	r.Use(BasicAuth(accounts))
+
+	r.GET("/login", func(c *Context) {
+		c.String(200, "autorized")
+	})
+
+	req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password")))
+	r.ServeHTTP(w, req)
+
+	if w.Code != 401 {
+		t.Errorf("Response code should be Not autorized, was: %s", w.Code)
+	}
+
+	if w.HeaderMap.Get("WWW-Authenticate") != "Basic realm=\"Authorization Required\"" {
+		t.Errorf("WWW-Authenticate header is incorrect: %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
diff --git a/context_test.go b/context_test.go
new file mode 100644
index 00000000..9a2394a2
--- /dev/null
+++ b/context_test.go
@@ -0,0 +1,452 @@
+package gin
+
+import (
+	"bytes"
+	"errors"
+	"html/template"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// TestContextParamsGet tests that a parameter can be parsed from the URL.
+func TestContextParamsByName(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test/alexandernyquist", nil)
+	w := httptest.NewRecorder()
+	name := ""
+
+	r := Default()
+	r.GET("/test/:name", func(c *Context) {
+		name = c.Params.ByName("name")
+	})
+
+	r.ServeHTTP(w, req)
+
+	if name != "alexandernyquist" {
+		t.Errorf("Url parameter was not correctly parsed. Should be alexandernyquist, was %s.", name)
+	}
+}
+
+// TestContextSetGet tests that a parameter is set correctly on the
+// current context and can be retrieved using Get.
+func TestContextSetGet(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+		// Key should be lazily created
+		if c.Keys != nil {
+			t.Error("Keys should be nil")
+		}
+
+		// Set
+		c.Set("foo", "bar")
+
+		v, err := c.Get("foo")
+		if err != nil {
+			t.Errorf("Error on exist key")
+		}
+		if v != "bar" {
+			t.Errorf("Value should be bar, was %s", v)
+		}
+	})
+
+	r.ServeHTTP(w, req)
+}
+
+// TestContextJSON tests that the response is serialized as JSON
+// and Content-Type is set to application/json
+func TestContextJSON(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+		c.JSON(200, H{"foo": "bar"})
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Body.String() != "{\"foo\":\"bar\"}\n" {
+		t.Errorf("Response should be {\"foo\":\"bar\"}, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "application/json" {
+		t.Errorf("Content-Type should be application/json, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestContextHTML tests that the response executes the templates
+// and responds with Content-Type set to text/html
+func TestContextHTML(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	templ, _ := template.New("t").Parse(`Hello {{.Name}}`)
+	r.SetHTMLTemplate(templ)
+
+	type TestData struct{ Name string }
+
+	r.GET("/test", func(c *Context) {
+		c.HTML(200, "t", TestData{"alexandernyquist"})
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Body.String() != "Hello alexandernyquist" {
+		t.Errorf("Response should be Hello alexandernyquist, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/html" {
+		t.Errorf("Content-Type should be text/html, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestContextString tests that the response is returned
+// with Content-Type set to text/plain
+func TestContextString(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+		c.String(200, "test")
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Body.String() != "test" {
+		t.Errorf("Response should be test, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/plain" {
+		t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestContextXML tests that the response is serialized as XML
+// and Content-Type is set to application/xml
+func TestContextXML(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+		c.XML(200, H{"foo": "bar"})
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Body.String() != "<map><foo>bar</foo></map>" {
+		t.Errorf("Response should be <map><foo>bar</foo></map>, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "application/xml" {
+		t.Errorf("Content-Type should be application/xml, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestContextData tests that the response can be written from `bytesting`
+// with specified MIME type
+func TestContextData(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test/csv", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test/csv", func(c *Context) {
+		c.Data(200, "text/csv", []byte(`foo,bar`))
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Body.String() != "foo,bar" {
+		t.Errorf("Response should be foo&bar, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/csv" {
+		t.Errorf("Content-Type should be text/csv, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+func TestContextFile(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test/file", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test/file", func(c *Context) {
+		c.File("./gin.go")
+	})
+
+	r.ServeHTTP(w, req)
+
+	bodyAsString := w.Body.String()
+
+	if len(bodyAsString) == 0 {
+		t.Errorf("Got empty body instead of file data")
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/plain; charset=utf-8" {
+		t.Errorf("Content-Type should be text/plain; charset=utf-8, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestHandlerFunc - ensure that custom middleware works properly
+func TestHandlerFunc(t *testing.T) {
+
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	var stepsPassed int = 0
+
+	r.Use(func(context *Context) {
+		stepsPassed += 1
+		context.Next()
+		stepsPassed += 1
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 404 {
+		t.Errorf("Response code should be Not found, was: %s", w.Code)
+	}
+
+	if stepsPassed != 2 {
+		t.Errorf("Falied to switch context in handler function: %s", stepsPassed)
+	}
+}
+
+// TestBadAbortHandlersChain - ensure that Abort after switch context will not interrupt pending handlers
+func TestBadAbortHandlersChain(t *testing.T) {
+
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	var stepsPassed int = 0
+
+	r.Use(func(context *Context) {
+		stepsPassed += 1
+		context.Next()
+		stepsPassed += 1
+		// after check and abort
+		context.Abort(409)
+	},
+		func(context *Context) {
+			stepsPassed += 1
+			context.Next()
+			stepsPassed += 1
+			context.Abort(403)
+		},
+	)
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 403 {
+		t.Errorf("Response code should be Forbiden, was: %s", w.Code)
+	}
+
+	if stepsPassed != 4 {
+		t.Errorf("Falied to switch context in handler function: %s", stepsPassed)
+	}
+}
+
+// TestAbortHandlersChain - ensure that Abort interrupt used middlewares in fifo order
+func TestAbortHandlersChain(t *testing.T) {
+
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	var stepsPassed int = 0
+
+	r.Use(func(context *Context) {
+		stepsPassed += 1
+		context.Abort(409)
+	},
+		func(context *Context) {
+			stepsPassed += 1
+			context.Next()
+			stepsPassed += 1
+		},
+	)
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 409 {
+		t.Errorf("Response code should be Conflict, was: %s", w.Code)
+	}
+
+	if stepsPassed != 1 {
+		t.Errorf("Falied to switch context in handler function: %s", stepsPassed)
+	}
+}
+
+// TestFailHandlersChain - ensure that Fail interrupt used middlewares in fifo order as
+// as well as Abort
+func TestFailHandlersChain(t *testing.T) {
+
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	var stepsPassed int = 0
+
+	r.Use(func(context *Context) {
+		stepsPassed += 1
+
+		context.Fail(500, errors.New("foo"))
+	},
+		func(context *Context) {
+			stepsPassed += 1
+			context.Next()
+			stepsPassed += 1
+		},
+	)
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 500 {
+		t.Errorf("Response code should be Server error, was: %s", w.Code)
+	}
+
+	if stepsPassed != 1 {
+		t.Errorf("Falied to switch context in handler function: %s", stepsPassed)
+	}
+
+}
+
+func TestBindingJSON(t *testing.T) {
+
+	body := bytes.NewBuffer([]byte("{\"foo\":\"bar\"}"))
+
+	r := Default()
+	r.POST("/binding/json", func(c *Context) {
+		var body struct {
+			Foo string `json:"foo"`
+		}
+		if c.Bind(&body) {
+			c.JSON(200, H{"parsed": body.Foo})
+		}
+	})
+
+	req, _ := http.NewRequest("POST", "/binding/json", body)
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+
+	if w.Body.String() != "{\"parsed\":\"bar\"}\n" {
+		t.Errorf("Response should be {\"parsed\":\"bar\"}, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "application/json" {
+		t.Errorf("Content-Type should be application/json, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+func TestBindingJSONEncoding(t *testing.T) {
+
+	body := bytes.NewBuffer([]byte("{\"foo\":\"嘉\"}"))
+
+	r := Default()
+	r.POST("/binding/json", func(c *Context) {
+		var body struct {
+			Foo string `json:"foo"`
+		}
+		if c.Bind(&body) {
+			c.JSON(200, H{"parsed": body.Foo})
+		}
+	})
+
+	req, _ := http.NewRequest("POST", "/binding/json", body)
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	w := httptest.NewRecorder()
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+
+	if w.Body.String() != "{\"parsed\":\"嘉\"}\n" {
+		t.Errorf("Response should be {\"parsed\":\"嘉\"}, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "application/json" {
+		t.Errorf("Content-Type should be application/json, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+func TestBindingJSONNoContentType(t *testing.T) {
+
+	body := bytes.NewBuffer([]byte("{\"foo\":\"bar\"}"))
+
+	r := Default()
+	r.POST("/binding/json", func(c *Context) {
+		var body struct {
+			Foo string `json:"foo"`
+		}
+		if c.Bind(&body) {
+			c.JSON(200, H{"parsed": body.Foo})
+		}
+
+	})
+
+	req, _ := http.NewRequest("POST", "/binding/json", body)
+	w := httptest.NewRecorder()
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 400 {
+		t.Errorf("Response code should be Bad request, was: %s", w.Code)
+	}
+
+	if w.Body.String() == "{\"parsed\":\"bar\"}\n" {
+		t.Errorf("Response should not be {\"parsed\":\"bar\"}, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") == "application/json" {
+		t.Errorf("Content-Type should not be application/json, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+func TestBindingJSONMalformed(t *testing.T) {
+
+	body := bytes.NewBuffer([]byte("\"foo\":\"bar\"\n"))
+
+	r := Default()
+	r.POST("/binding/json", func(c *Context) {
+		var body struct {
+			Foo string `json:"foo"`
+		}
+		if c.Bind(&body) {
+			c.JSON(200, H{"parsed": body.Foo})
+		}
+
+	})
+
+	req, _ := http.NewRequest("POST", "/binding/json", body)
+	req.Header.Set("Content-Type", "application/json")
+
+	w := httptest.NewRecorder()
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 400 {
+		t.Errorf("Response code should be Bad request, was: %s", w.Code)
+	}
+	if w.Body.String() == "{\"parsed\":\"bar\"}\n" {
+		t.Errorf("Response should not be {\"parsed\":\"bar\"}, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") == "application/json" {
+		t.Errorf("Content-Type should not be application/json, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
diff --git a/gin_test.go b/gin_test.go
new file mode 100644
index 00000000..61b3c351
--- /dev/null
+++ b/gin_test.go
@@ -0,0 +1,295 @@
+package gin
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path"
+	"strings"
+	"testing"
+)
+
+// TestRouterGroupGETRouteOK tests that GET route is correctly invoked.
+func TestRouterGroupGETRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("GET route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupGETNoRootExistsRouteOK tests that a GET requse to root is correctly
+// handled (404) when no root route exists.
+func TestRouterGroupGETNoRootExistsRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.GET("/test", func(c *Context) {
+	})
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		// If this fails, it's because httprouter needs to be updated to at least f78f58a0db
+		t.Errorf("Status code should be %v, was %d. Location: %s", http.StatusNotFound, w.Code, w.HeaderMap.Get("Location"))
+	}
+}
+
+// TestRouterGroupPOSTRouteOK tests that POST route is correctly invoked.
+func TestRouterGroupPOSTRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("POST", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.POST("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("POST route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupDELETERouteOK tests that DELETE route is correctly invoked.
+func TestRouterGroupDELETERouteOK(t *testing.T) {
+	req, _ := http.NewRequest("DELETE", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.DELETE("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("DELETE route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupPATCHRouteOK tests that PATCH route is correctly invoked.
+func TestRouterGroupPATCHRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("PATCH", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.PATCH("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("PATCH route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupPUTRouteOK tests that PUT route is correctly invoked.
+func TestRouterGroupPUTRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("PUT", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.PUT("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("PUT route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupOPTIONSRouteOK tests that OPTIONS route is correctly invoked.
+func TestRouterGroupOPTIONSRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("OPTIONS", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.OPTIONS("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("OPTIONS route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroupHEADRouteOK tests that HEAD route is correctly invoked.
+func TestRouterGroupHEADRouteOK(t *testing.T) {
+	req, _ := http.NewRequest("HEAD", "/test", nil)
+	w := httptest.NewRecorder()
+	passed := false
+
+	r := Default()
+	r.HEAD("/test", func(c *Context) {
+		passed = true
+	})
+
+	r.ServeHTTP(w, req)
+
+	if passed == false {
+		t.Errorf("HEAD route handler was not invoked.")
+	}
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code)
+	}
+}
+
+// TestRouterGroup404 tests that 404 is returned for a route that does not exist.
+func TestEngine404(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/", nil)
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("Response code should be %v, was %d", http.StatusNotFound, w.Code)
+	}
+}
+
+// TestHandleStaticFile - ensure the static file handles properly
+func TestHandleStaticFile(t *testing.T) {
+
+	testRoot, _ := os.Getwd()
+
+	f, err := ioutil.TempFile(testRoot, "")
+	defer os.Remove(f.Name())
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	filePath := path.Join("/", path.Base(f.Name()))
+	req, _ := http.NewRequest("GET", filePath, nil)
+
+	f.WriteString("Gin Web Framework")
+	f.Close()
+
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.Static("./", testRoot)
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+
+	if w.Body.String() != "Gin Web Framework" {
+		t.Errorf("Response should be test, was: %s", w.Body.String())
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/plain; charset=utf-8" {
+		t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestHandleStaticDir - ensure the root/sub dir handles properly
+func TestHandleStaticDir(t *testing.T) {
+
+	req, _ := http.NewRequest("GET", "/", nil)
+
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.Static("/", "./")
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+
+	bodyAsString := w.Body.String()
+
+	if len(bodyAsString) == 0 {
+		t.Errorf("Got empty body instead of file tree")
+	}
+
+	if !strings.Contains(bodyAsString, "gin.go") {
+		t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString)
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" {
+		t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
+
+// TestHandleHeadToDir - ensure the root/sub dir handles properly
+func TestHandleHeadToDir(t *testing.T) {
+
+	req, _ := http.NewRequest("HEAD", "/", nil)
+
+	w := httptest.NewRecorder()
+
+	r := Default()
+	r.Static("/", "./")
+
+	r.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Errorf("Response code should be Ok, was: %s", w.Code)
+	}
+
+	bodyAsString := w.Body.String()
+
+	if len(bodyAsString) == 0 {
+		t.Errorf("Got empty body instead of file tree")
+	}
+	if !strings.Contains(bodyAsString, "gin.go") {
+		t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString)
+	}
+
+	if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" {
+		t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type"))
+	}
+}
diff --git a/recovery_test.go b/recovery_test.go
new file mode 100644
index 00000000..7383a1df
--- /dev/null
+++ b/recovery_test.go
@@ -0,0 +1,80 @@
+package gin
+
+import (
+	"bytes"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+// TestPanicInHandler assert that panic has been recovered.
+func TestPanicInHandler(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/recovery", nil)
+	w := httptest.NewRecorder()
+
+	// Disable panic logs for testing
+	log.SetOutput(bytes.NewBuffer(nil))
+
+	r := Default()
+	r.GET("/recovery", func(_ *Context) {
+		panic("Oupps, Houston, we have a problem")
+	})
+
+	r.ServeHTTP(w, req)
+
+	// restore logging
+	log.SetOutput(os.Stderr)
+
+	if w.Code != 500 {
+		t.Errorf("Response code should be Internal Server Error, was: %s", w.Code)
+	}
+	bodyAsString := w.Body.String()
+
+	//fixme: no message provided?
+	if bodyAsString != "" {
+		t.Errorf("Response body should be empty, was  %s", bodyAsString)
+	}
+	//fixme:
+	if len(w.HeaderMap) != 0 {
+		t.Errorf("No headers should be provided, was %s", w.HeaderMap)
+	}
+
+}
+
+// TestPanicWithAbort assert that panic has been recovered even if context.Abort was used.
+func TestPanicWithAbort(t *testing.T) {
+	req, _ := http.NewRequest("GET", "/recovery", nil)
+	w := httptest.NewRecorder()
+
+	// Disable panic logs for testing
+	log.SetOutput(bytes.NewBuffer(nil))
+
+	r := Default()
+	r.GET("/recovery", func(c *Context) {
+		c.Abort(400)
+		panic("Oupps, Houston, we have a problem")
+	})
+
+	r.ServeHTTP(w, req)
+
+	// restore logging
+	log.SetOutput(os.Stderr)
+
+	// fixme: why not 500?
+	if w.Code != 400 {
+		t.Errorf("Response code should be Bad request, was: %s", w.Code)
+	}
+	bodyAsString := w.Body.String()
+
+	//fixme: no message provided?
+	if bodyAsString != "" {
+		t.Errorf("Response body should be empty, was  %s", bodyAsString)
+	}
+	//fixme:
+	if len(w.HeaderMap) != 0 {
+		t.Errorf("No headers should be provided, was %s", w.HeaderMap)
+	}
+
+}