diff -pruN 1.7.0-1/debian/changelog 1.7.0-2/debian/changelog
--- 1.7.0-1/debian/changelog	2020-11-21 05:04:14.000000000 +0000
+++ 1.7.0-2/debian/changelog	2022-02-08 17:50:50.000000000 +0000
@@ -1,3 +1,13 @@
+golang-github-bugsnag-bugsnag-go (1.7.0-2) unstable; urgency=medium
+
+  * Team upload
+  * Simplify dependency graph.
+    By not packaging integration with other libraries
+  * Update Standards-Version to 4.6.0 (no changes)
+  * Add Multi-Arch hint
+
+ -- Shengjing Zhu <zhsj@debian.org>  Wed, 09 Feb 2022 01:50:50 +0800
+
 golang-github-bugsnag-bugsnag-go (1.7.0-1) unstable; urgency=medium
 
   [ Debian Janitor ]
diff -pruN 1.7.0-1/debian/control 1.7.0-2/debian/control
--- 1.7.0-1/debian/control	2020-11-21 04:42:06.000000000 +0000
+++ 1.7.0-2/debian/control	2022-02-08 17:50:50.000000000 +0000
@@ -1,7 +1,7 @@
 Source: golang-github-bugsnag-bugsnag-go
 Maintainer: Debian Go Packaging Team <team+pkg-go@tracker.debian.org>
 Uploaders: Tim Potter <tpot@hp.com>,
-           Anthony Fok <foka@debian.org>
+           Anthony Fok <foka@debian.org>,
 Section: golang
 Testsuite: autopkgtest-pkg-go
 Priority: optional
@@ -10,14 +10,10 @@ Build-Depends: debhelper-compat (= 13),
                golang-any,
                golang-github-bitly-go-simplejson-dev,
                golang-github-bugsnag-panicwrap-dev,
-               golang-github-gin-gonic-gin-dev,
                golang-github-gofrs-uuid-dev,
-               golang-github-juju-loggo-dev,
                golang-github-kardianos-osext-dev,
                golang-github-pkg-errors-dev,
-               golang-github-revel-revel-dev (>= 1.0.0),
-               golang-github-urfave-negroni-dev
-Standards-Version: 4.5.0
+Standards-Version: 4.6.0
 Vcs-Browser: https://salsa.debian.org/go-team/packages/golang-bugsnag-go
 Vcs-Git: https://salsa.debian.org/go-team/packages/golang-bugsnag-go.git
 Homepage: https://github.com/bugsnag/bugsnag-go
@@ -26,16 +22,11 @@ XS-Go-Import-Path: github.com/bugsnag/bu
 
 Package: golang-github-bugsnag-bugsnag-go-dev
 Architecture: all
-Depends: golang-github-bitly-go-simplejson-dev,
-         golang-github-bugsnag-panicwrap-dev,
-         golang-github-gin-gonic-gin-dev,
+Depends: golang-github-bugsnag-panicwrap-dev,
          golang-github-gofrs-uuid-dev,
-         golang-github-juju-loggo-dev,
-         golang-github-kardianos-osext-dev,
          golang-github-pkg-errors-dev,
-         golang-github-revel-revel-dev (>= 1.0.0),
-         golang-github-urfave-negroni-dev,
-         ${misc:Depends}
+         ${misc:Depends},
+Multi-Arch: foreign
 Description: automatic panic monitoring for Go applications
  The Bugsnag Notifier for Golang gives you instant notification of
  panics, or unexpected errors, in your golang app. Any unhandled panics
diff -pruN 1.7.0-1/debian/gitlab-ci.yml 1.7.0-2/debian/gitlab-ci.yml
--- 1.7.0-1/debian/gitlab-ci.yml	1970-01-01 00:00:00.000000000 +0000
+++ 1.7.0-2/debian/gitlab-ci.yml	2022-02-08 17:50:50.000000000 +0000
@@ -0,0 +1,6 @@
+# auto-generated, DO NOT MODIFY.
+# The authoritative copy of this file lives at:
+# https://salsa.debian.org/go-team/infra/pkg-go-tools/blob/master/config/gitlabciyml.go
+---
+include:
+  - https://salsa.debian.org/go-team/infra/pkg-go-tools/-/raw/master/pipeline/test-archive.yml
diff -pruN 1.7.0-1/debian/go/src/github.com/codegangsta/inject/inject.go 1.7.0-2/debian/go/src/github.com/codegangsta/inject/inject.go
--- 1.7.0-1/debian/go/src/github.com/codegangsta/inject/inject.go	2020-11-19 19:46:56.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/codegangsta/inject/inject.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,187 +0,0 @@
-// Package inject provides utilities for mapping and injecting dependencies in various ways.
-package inject
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// Injector represents an interface for mapping and injecting dependencies into structs
-// and function arguments.
-type Injector interface {
-	Applicator
-	Invoker
-	TypeMapper
-	// SetParent sets the parent of the injector. If the injector cannot find a
-	// dependency in its Type map it will check its parent before returning an
-	// error.
-	SetParent(Injector)
-}
-
-// Applicator represents an interface for mapping dependencies to a struct.
-type Applicator interface {
-	// Maps dependencies in the Type map to each field in the struct
-	// that is tagged with 'inject'. Returns an error if the injection
-	// fails.
-	Apply(interface{}) error
-}
-
-// Invoker represents an interface for calling functions via reflection.
-type Invoker interface {
-	// Invoke attempts to call the interface{} provided as a function,
-	// providing dependencies for function arguments based on Type. Returns
-	// a slice of reflect.Value representing the returned values of the function.
-	// Returns an error if the injection fails.
-	Invoke(interface{}) ([]reflect.Value, error)
-}
-
-// TypeMapper represents an interface for mapping interface{} values based on type.
-type TypeMapper interface {
-	// Maps the interface{} value based on its immediate type from reflect.TypeOf.
-	Map(interface{}) TypeMapper
-	// Maps the interface{} value based on the pointer of an Interface provided.
-	// This is really only useful for mapping a value as an interface, as interfaces
-	// cannot at this time be referenced directly without a pointer.
-	MapTo(interface{}, interface{}) TypeMapper
-	// Provides a possibility to directly insert a mapping based on type and value.
-	// This makes it possible to directly map type arguments not possible to instantiate
-	// with reflect like unidirectional channels.
-	Set(reflect.Type, reflect.Value) TypeMapper
-	// Returns the Value that is mapped to the current type. Returns a zeroed Value if
-	// the Type has not been mapped.
-	Get(reflect.Type) reflect.Value
-}
-
-type injector struct {
-	values map[reflect.Type]reflect.Value
-	parent Injector
-}
-
-// InterfaceOf dereferences a pointer to an Interface type.
-// It panics if value is not an pointer to an interface.
-func InterfaceOf(value interface{}) reflect.Type {
-	t := reflect.TypeOf(value)
-
-	for t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-
-	if t.Kind() != reflect.Interface {
-		panic("Called inject.InterfaceOf with a value that is not a pointer to an interface. (*MyInterface)(nil)")
-	}
-
-	return t
-}
-
-// New returns a new Injector.
-func New() Injector {
-	return &injector{
-		values: make(map[reflect.Type]reflect.Value),
-	}
-}
-
-// Invoke attempts to call the interface{} provided as a function,
-// providing dependencies for function arguments based on Type.
-// Returns a slice of reflect.Value representing the returned values of the function.
-// Returns an error if the injection fails.
-// It panics if f is not a function
-func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
-	t := reflect.TypeOf(f)
-
-	var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func
-	for i := 0; i < t.NumIn(); i++ {
-		argType := t.In(i)
-		val := inj.Get(argType)
-		if !val.IsValid() {
-			return nil, fmt.Errorf("Value not found for type %v", argType)
-		}
-
-		in[i] = val
-	}
-
-	return reflect.ValueOf(f).Call(in), nil
-}
-
-// Maps dependencies in the Type map to each field in the struct
-// that is tagged with 'inject'.
-// Returns an error if the injection fails.
-func (inj *injector) Apply(val interface{}) error {
-	v := reflect.ValueOf(val)
-
-	for v.Kind() == reflect.Ptr {
-		v = v.Elem()
-	}
-
-	if v.Kind() != reflect.Struct {
-		return nil // Should not panic here ?
-	}
-
-	t := v.Type()
-
-	for i := 0; i < v.NumField(); i++ {
-		f := v.Field(i)
-		structField := t.Field(i)
-		if f.CanSet() && (structField.Tag == "inject" || structField.Tag.Get("inject") != "") {
-			ft := f.Type()
-			v := inj.Get(ft)
-			if !v.IsValid() {
-				return fmt.Errorf("Value not found for type %v", ft)
-			}
-
-			f.Set(v)
-		}
-
-	}
-
-	return nil
-}
-
-// Maps the concrete value of val to its dynamic type using reflect.TypeOf,
-// It returns the TypeMapper registered in.
-func (i *injector) Map(val interface{}) TypeMapper {
-	i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
-	return i
-}
-
-func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
-	i.values[InterfaceOf(ifacePtr)] = reflect.ValueOf(val)
-	return i
-}
-
-// Maps the given reflect.Type to the given reflect.Value and returns
-// the Typemapper the mapping has been registered in.
-func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
-	i.values[typ] = val
-	return i
-}
-
-func (i *injector) Get(t reflect.Type) reflect.Value {
-	val := i.values[t]
-
-	if val.IsValid() {
-		return val
-	}
-
-	// no concrete types found, try to find implementors
-	// if t is an interface
-	if t.Kind() == reflect.Interface {
-		for k, v := range i.values {
-			if k.Implements(t) {
-				val = v
-				break
-			}
-		}
-	}
-
-	// Still no type found, try to look it up on the parent
-	if !val.IsValid() && i.parent != nil {
-		val = i.parent.Get(t)
-	}
-
-	return val
-
-}
-
-func (i *injector) SetParent(parent Injector) {
-	i.parent = parent
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/codegangsta/inject/inject_test.go 1.7.0-2/debian/go/src/github.com/codegangsta/inject/inject_test.go
--- 1.7.0-1/debian/go/src/github.com/codegangsta/inject/inject_test.go	2020-11-19 19:46:56.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/codegangsta/inject/inject_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,159 +0,0 @@
-package inject_test
-
-import (
-	"fmt"
-	"github.com/codegangsta/inject"
-	"reflect"
-	"testing"
-)
-
-type SpecialString interface {
-}
-
-type TestStruct struct {
-	Dep1 string        `inject:"t" json:"-"`
-	Dep2 SpecialString `inject`
-	Dep3 string
-}
-
-type Greeter struct {
-	Name string
-}
-
-func (g *Greeter) String() string {
-	return "Hello, My name is" + g.Name
-}
-
-/* Test Helpers */
-func expect(t *testing.T, a interface{}, b interface{}) {
-	if a != b {
-		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func Test_InjectorInvoke(t *testing.T) {
-	injector := inject.New()
-	expect(t, injector == nil, false)
-
-	dep := "some dependency"
-	injector.Map(dep)
-	dep2 := "another dep"
-	injector.MapTo(dep2, (*SpecialString)(nil))
-	dep3 := make(chan *SpecialString)
-	dep4 := make(chan *SpecialString)
-	typRecv := reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(dep3).Elem())
-	typSend := reflect.ChanOf(reflect.SendDir, reflect.TypeOf(dep4).Elem())
-	injector.Set(typRecv, reflect.ValueOf(dep3))
-	injector.Set(typSend, reflect.ValueOf(dep4))
-
-	_, err := injector.Invoke(func(d1 string, d2 SpecialString, d3 <-chan *SpecialString, d4 chan<- *SpecialString) {
-		expect(t, d1, dep)
-		expect(t, d2, dep2)
-		expect(t, reflect.TypeOf(d3).Elem(), reflect.TypeOf(dep3).Elem())
-		expect(t, reflect.TypeOf(d4).Elem(), reflect.TypeOf(dep4).Elem())
-		expect(t, reflect.TypeOf(d3).ChanDir(), reflect.RecvDir)
-		expect(t, reflect.TypeOf(d4).ChanDir(), reflect.SendDir)
-	})
-
-	expect(t, err, nil)
-}
-
-func Test_InjectorInvokeReturnValues(t *testing.T) {
-	injector := inject.New()
-	expect(t, injector == nil, false)
-
-	dep := "some dependency"
-	injector.Map(dep)
-	dep2 := "another dep"
-	injector.MapTo(dep2, (*SpecialString)(nil))
-
-	result, err := injector.Invoke(func(d1 string, d2 SpecialString) string {
-		expect(t, d1, dep)
-		expect(t, d2, dep2)
-		return "Hello world"
-	})
-
-	expect(t, result[0].String(), "Hello world")
-	expect(t, err, nil)
-}
-
-func Test_InjectorApply(t *testing.T) {
-	injector := inject.New()
-
-	injector.Map("a dep").MapTo("another dep", (*SpecialString)(nil))
-
-	s := TestStruct{}
-	err := injector.Apply(&s)
-	expect(t, err, nil)
-
-	expect(t, s.Dep1, "a dep")
-	expect(t, s.Dep2, "another dep")
-	expect(t, s.Dep3, "")
-}
-
-func Test_InterfaceOf(t *testing.T) {
-	iType := inject.InterfaceOf((*SpecialString)(nil))
-	expect(t, iType.Kind(), reflect.Interface)
-
-	iType = inject.InterfaceOf((**SpecialString)(nil))
-	expect(t, iType.Kind(), reflect.Interface)
-
-	// Expecting nil
-	defer func() {
-		rec := recover()
-		refute(t, rec, nil)
-	}()
-	iType = inject.InterfaceOf((*testing.T)(nil))
-}
-
-func Test_InjectorSet(t *testing.T) {
-	injector := inject.New()
-	typ := reflect.TypeOf("string")
-	typSend := reflect.ChanOf(reflect.SendDir, typ)
-	typRecv := reflect.ChanOf(reflect.RecvDir, typ)
-
-	// instantiating unidirectional channels is not possible using reflect
-	// http://golang.org/src/pkg/reflect/value.go?s=60463:60504#L2064
-	chanRecv := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)
-	chanSend := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)
-
-	injector.Set(typSend, chanSend)
-	injector.Set(typRecv, chanRecv)
-
-	expect(t, injector.Get(typSend).IsValid(), true)
-	expect(t, injector.Get(typRecv).IsValid(), true)
-	expect(t, injector.Get(chanSend.Type()).IsValid(), false)
-}
-
-func Test_InjectorGet(t *testing.T) {
-	injector := inject.New()
-
-	injector.Map("some dependency")
-
-	expect(t, injector.Get(reflect.TypeOf("string")).IsValid(), true)
-	expect(t, injector.Get(reflect.TypeOf(11)).IsValid(), false)
-}
-
-func Test_InjectorSetParent(t *testing.T) {
-	injector := inject.New()
-	injector.MapTo("another dep", (*SpecialString)(nil))
-
-	injector2 := inject.New()
-	injector2.SetParent(injector)
-
-	expect(t, injector2.Get(inject.InterfaceOf((*SpecialString)(nil))).IsValid(), true)
-}
-
-func TestInjectImplementors(t *testing.T) {
-	injector := inject.New()
-	g := &Greeter{"Jeremy"}
-	injector.Map(g)
-
-	expect(t, injector.Get(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), true)
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/env.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/env.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/env.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/env.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,31 +0,0 @@
-package martini
-
-import (
-	"os"
-)
-
-// Envs
-const (
-	Dev  string = "development"
-	Prod string = "production"
-	Test string = "test"
-)
-
-// Env is the environment that Martini is executing in. The MARTINI_ENV is read on initialization to set this variable.
-var Env = Dev
-var Root string
-
-func setENV(e string) {
-	if len(e) > 0 {
-		Env = e
-	}
-}
-
-func init() {
-	setENV(os.Getenv("MARTINI_ENV"))
-	var err error
-	Root, err = os.Getwd()
-	if err != nil {
-		panic(err)
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/env_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/env_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/env_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/env_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,28 +0,0 @@
-package martini
-
-import (
-	"testing"
-)
-
-func Test_SetENV(t *testing.T) {
-	tests := []struct {
-		in  string
-		out string
-	}{
-		{"", "development"},
-		{"not_development", "not_development"},
-	}
-
-	for _, test := range tests {
-		setENV(test.in)
-		if Env != test.out {
-			expect(t, Env, test.out)
-		}
-	}
-}
-
-func Test_Root(t *testing.T) {
-	if len(Root) == 0 {
-		t.Errorf("Expected root path will be set")
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/go_version.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/go_version.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/go_version.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/go_version.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,7 +0,0 @@
-// +build !go1.1
-
-package martini
-
-func MartiniDoesNotSupportGo1Point0() {
-	"Martini requires Go 1.1 or greater."
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/logger.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/logger.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/logger.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/logger.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,29 +0,0 @@
-package martini
-
-import (
-	"log"
-	"net/http"
-	"time"
-)
-
-// Logger returns a middleware handler that logs the request as it goes in and the response as it goes out.
-func Logger() Handler {
-	return func(res http.ResponseWriter, req *http.Request, c Context, log *log.Logger) {
-		start := time.Now()
-
-		addr := req.Header.Get("X-Real-IP")
-		if addr == "" {
-			addr = req.Header.Get("X-Forwarded-For")
-			if addr == "" {
-				addr = req.RemoteAddr
-			}
-		}
-
-		log.Printf("Started %s %s for %s", req.Method, req.URL.Path, addr)
-
-		rw := res.(ResponseWriter)
-		c.Next()
-
-		log.Printf("Completed %v %s in %v\n", rw.Status(), http.StatusText(rw.Status()), time.Since(start))
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/logger_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/logger_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/logger_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/logger_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,31 +0,0 @@
-package martini
-
-import (
-	"bytes"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func Test_Logger(t *testing.T) {
-	buff := bytes.NewBufferString("")
-	recorder := httptest.NewRecorder()
-
-	m := New()
-	// replace log for testing
-	m.Map(log.New(buff, "[martini] ", 0))
-	m.Use(Logger())
-	m.Use(func(res http.ResponseWriter) {
-		res.WriteHeader(http.StatusNotFound)
-	})
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/foobar", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(recorder, req)
-	expect(t, recorder.Code, http.StatusNotFound)
-	refute(t, len(buff.String()), 0)
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/martini.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/martini.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/martini.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/martini.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,189 +0,0 @@
-// Package martini is a powerful package for quickly writing modular web applications/services in Golang.
-//
-// For a full guide visit http://github.com/go-martini/martini
-//
-//  package main
-//
-//  import "github.com/go-martini/martini"
-//
-//  func main() {
-//    m := martini.Classic()
-//
-//    m.Get("/", func() string {
-//      return "Hello world!"
-//    })
-//
-//    m.Run()
-//  }
-package martini
-
-import (
-	"log"
-	"net/http"
-	"os"
-	"reflect"
-
-	"github.com/codegangsta/inject"
-)
-
-// Martini represents the top level web application. inject.Injector methods can be invoked to map services on a global level.
-type Martini struct {
-	inject.Injector
-	handlers []Handler
-	action   Handler
-	logger   *log.Logger
-}
-
-// New creates a bare bones Martini instance. Use this method if you want to have full control over the middleware that is used.
-func New() *Martini {
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(os.Stdout, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-	return m
-}
-
-// Handlers sets the entire middleware stack with the given Handlers. This will clear any current middleware handlers.
-// Will panic if any of the handlers is not a callable function
-func (m *Martini) Handlers(handlers ...Handler) {
-	m.handlers = make([]Handler, 0)
-	for _, handler := range handlers {
-		m.Use(handler)
-	}
-}
-
-// Action sets the handler that will be called after all the middleware has been invoked. This is set to martini.Router in a martini.Classic().
-func (m *Martini) Action(handler Handler) {
-	validateHandler(handler)
-	m.action = handler
-}
-
-// Logger sets the logger
-func (m *Martini) Logger(logger *log.Logger) {
-	m.logger = logger
-	m.Map(m.logger)
-}
-
-// Use adds a middleware Handler to the stack. Will panic if the handler is not a callable func. Middleware Handlers are invoked in the order that they are added.
-func (m *Martini) Use(handler Handler) {
-	validateHandler(handler)
-
-	m.handlers = append(m.handlers, handler)
-}
-
-// ServeHTTP is the HTTP Entry point for a Martini instance. Useful if you want to control your own HTTP server.
-func (m *Martini) ServeHTTP(res http.ResponseWriter, req *http.Request) {
-	m.createContext(res, req).run()
-}
-
-// Run the http server on a given host and port.
-func (m *Martini) RunOnAddr(addr string) {
-	// TODO: Should probably be implemented using a new instance of http.Server in place of
-	// calling http.ListenAndServer directly, so that it could be stored in the martini struct for later use.
-	// This would also allow to improve testing when a custom host and port are passed.
-
-	logger := m.Injector.Get(reflect.TypeOf(m.logger)).Interface().(*log.Logger)
-	logger.Printf("listening on %s (%s)\n", addr, Env)
-	logger.Fatalln(http.ListenAndServe(addr, m))
-}
-
-// Run the http server. Listening on os.GetEnv("PORT") or 3000 by default.
-func (m *Martini) Run() {
-	port := os.Getenv("PORT")
-	if len(port) == 0 {
-		port = "3000"
-	}
-
-	host := os.Getenv("HOST")
-
-	m.RunOnAddr(host + ":" + port)
-}
-
-func (m *Martini) createContext(res http.ResponseWriter, req *http.Request) *context {
-	c := &context{inject.New(), m.handlers, m.action, NewResponseWriter(res), 0}
-	c.SetParent(m)
-	c.MapTo(c, (*Context)(nil))
-	c.MapTo(c.rw, (*http.ResponseWriter)(nil))
-	c.Map(req)
-	return c
-}
-
-// ClassicMartini represents a Martini with some reasonable defaults. Embeds the router functions for convenience.
-type ClassicMartini struct {
-	*Martini
-	Router
-}
-
-// Classic creates a classic Martini with some basic default middleware - martini.Logger, martini.Recovery and martini.Static.
-// Classic also maps martini.Routes as a service.
-func Classic() *ClassicMartini {
-	r := NewRouter()
-	m := New()
-	m.Use(Logger())
-	m.Use(Recovery())
-	m.Use(Static("public"))
-	m.MapTo(r, (*Routes)(nil))
-	m.Action(r.Handle)
-	return &ClassicMartini{m, r}
-}
-
-// Handler can be any callable function. Martini attempts to inject services into the handler's argument list.
-// Martini will panic if an argument could not be fullfilled via dependency injection.
-type Handler interface{}
-
-func validateHandler(handler Handler) {
-	if reflect.TypeOf(handler).Kind() != reflect.Func {
-		panic("martini handler must be a callable func")
-	}
-}
-
-// Context represents a request context. Services can be mapped on the request level from this interface.
-type Context interface {
-	inject.Injector
-	// Next is an optional function that Middleware Handlers can call to yield the until after
-	// the other Handlers have been executed. This works really well for any operations that must
-	// happen after an http request
-	Next()
-	// Written returns whether or not the response for this context has been written.
-	Written() bool
-}
-
-type context struct {
-	inject.Injector
-	handlers []Handler
-	action   Handler
-	rw       ResponseWriter
-	index    int
-}
-
-func (c *context) handler() Handler {
-	if c.index < len(c.handlers) {
-		return c.handlers[c.index]
-	}
-	if c.index == len(c.handlers) {
-		return c.action
-	}
-	panic("invalid index for context handler")
-}
-
-func (c *context) Next() {
-	c.index += 1
-	c.run()
-}
-
-func (c *context) Written() bool {
-	return c.rw.Written()
-}
-
-func (c *context) run() {
-	for c.index <= len(c.handlers) {
-		_, err := c.Invoke(c.handler())
-		if err != nil {
-			panic(err)
-		}
-		c.index += 1
-
-		if c.Written() {
-			return
-		}
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/martini_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/martini_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/martini_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/martini_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,145 +0,0 @@
-package martini
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"reflect"
-	"testing"
-)
-
-/* Test Helpers */
-func expect(t *testing.T, a interface{}, b interface{}) {
-	if a != b {
-		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func Test_New(t *testing.T) {
-	m := New()
-	if m == nil {
-		t.Error("martini.New() cannot return nil")
-	}
-}
-
-func Test_Martini_RunOnAddr(t *testing.T) {
-	// just test that Run doesn't bomb
-	go New().RunOnAddr("127.0.0.1:8080")
-}
-
-func Test_Martini_Run(t *testing.T) {
-	go New().Run()
-}
-
-func Test_Martini_ServeHTTP(t *testing.T) {
-	result := ""
-	response := httptest.NewRecorder()
-
-	m := New()
-	m.Use(func(c Context) {
-		result += "foo"
-		c.Next()
-		result += "ban"
-	})
-	m.Use(func(c Context) {
-		result += "bar"
-		c.Next()
-		result += "baz"
-	})
-	m.Action(func(res http.ResponseWriter, req *http.Request) {
-		result += "bat"
-		res.WriteHeader(http.StatusBadRequest)
-	})
-
-	m.ServeHTTP(response, (*http.Request)(nil))
-
-	expect(t, result, "foobarbatbazban")
-	expect(t, response.Code, http.StatusBadRequest)
-}
-
-func Test_Martini_Handlers(t *testing.T) {
-	result := ""
-	response := httptest.NewRecorder()
-
-	batman := func(c Context) {
-		result += "batman!"
-	}
-
-	m := New()
-	m.Use(func(c Context) {
-		result += "foo"
-		c.Next()
-		result += "ban"
-	})
-	m.Handlers(
-		batman,
-		batman,
-		batman,
-	)
-	m.Action(func(res http.ResponseWriter, req *http.Request) {
-		result += "bat"
-		res.WriteHeader(http.StatusBadRequest)
-	})
-
-	m.ServeHTTP(response, (*http.Request)(nil))
-
-	expect(t, result, "batman!batman!batman!bat")
-	expect(t, response.Code, http.StatusBadRequest)
-}
-
-func Test_Martini_EarlyWrite(t *testing.T) {
-	result := ""
-	response := httptest.NewRecorder()
-
-	m := New()
-	m.Use(func(res http.ResponseWriter) {
-		result += "foobar"
-		res.Write([]byte("Hello world"))
-	})
-	m.Use(func() {
-		result += "bat"
-	})
-	m.Action(func(res http.ResponseWriter) {
-		result += "baz"
-		res.WriteHeader(http.StatusBadRequest)
-	})
-
-	m.ServeHTTP(response, (*http.Request)(nil))
-
-	expect(t, result, "foobar")
-	expect(t, response.Code, http.StatusOK)
-}
-
-func Test_Martini_Written(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	m := New()
-	m.Handlers(func(res http.ResponseWriter) {
-		res.WriteHeader(http.StatusOK)
-	})
-
-	ctx := m.createContext(response, (*http.Request)(nil))
-	expect(t, ctx.Written(), false)
-
-	ctx.run()
-	expect(t, ctx.Written(), true)
-}
-
-func Test_Martini_Basic_NoRace(t *testing.T) {
-	m := New()
-	handlers := []Handler{func() {}, func() {}}
-	// Ensure append will not realloc to trigger the race condition
-	m.handlers = handlers[:1]
-	req, _ := http.NewRequest("GET", "/", nil)
-	for i := 0; i < 2; i++ {
-		go func() {
-			response := httptest.NewRecorder()
-			m.ServeHTTP(response, req)
-		}()
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/recovery.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/recovery.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/recovery.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/recovery.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,144 +0,0 @@
-package martini
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"runtime"
-
-	"github.com/codegangsta/inject"
-)
-
-const (
-	panicHtml = `<html>
-<head><title>PANIC: %s</title>
-<style type="text/css">
-html, body {
-	font-family: "Roboto", sans-serif;
-	color: #333333;
-	background-color: #ea5343;
-	margin: 0px;
-}
-h1 {
-	color: #d04526;
-	background-color: #ffffff;
-	padding: 20px;
-	border-bottom: 1px dashed #2b3848;
-}
-pre {
-	margin: 20px;
-	padding: 20px;
-	border: 2px solid #2b3848;
-	background-color: #ffffff;
-}
-</style>
-</head><body>
-<h1>PANIC</h1>
-<pre style="font-weight: bold;">%s</pre>
-<pre>%s</pre>
-</body>
-</html>`
-)
-
-var (
-	dunno     = []byte("???")
-	centerDot = []byte("·")
-	dot       = []byte(".")
-	slash     = []byte("/")
-)
-
-// stack returns a nicely formated stack frame, skipping skip frames
-func stack(skip int) []byte {
-	buf := new(bytes.Buffer) // the returned data
-	// As we loop, we open files and read them. These variables record the currently
-	// loaded file.
-	var lines [][]byte
-	var lastFile string
-	for i := skip; ; i++ { // Skip the expected number of frames
-		pc, file, line, ok := runtime.Caller(i)
-		if !ok {
-			break
-		}
-		// Print this much at least.  If we can't find the source, it won't show.
-		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
-		if file != lastFile {
-			data, err := ioutil.ReadFile(file)
-			if err != nil {
-				continue
-			}
-			lines = bytes.Split(data, []byte{'\n'})
-			lastFile = file
-		}
-		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
-	}
-	return buf.Bytes()
-}
-
-// source returns a space-trimmed slice of the n'th line.
-func source(lines [][]byte, n int) []byte {
-	n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
-	if n < 0 || n >= len(lines) {
-		return dunno
-	}
-	return bytes.TrimSpace(lines[n])
-}
-
-// function returns, if possible, the name of the function containing the PC.
-func function(pc uintptr) []byte {
-	fn := runtime.FuncForPC(pc)
-	if fn == nil {
-		return dunno
-	}
-	name := []byte(fn.Name())
-	// The name includes the path name to the package, which is unnecessary
-	// since the file name is already included.  Plus, it has center dots.
-	// That is, we see
-	//	runtime/debug.*T·ptrmethod
-	// and want
-	//	*T.ptrmethod
-	// Also the package path might contains dot (e.g. code.google.com/...),
-	// so first eliminate the path prefix
-	if lastslash := bytes.LastIndex(name, slash); lastslash >= 0 {
-		name = name[lastslash+1:]
-	}
-	if period := bytes.Index(name, dot); period >= 0 {
-		name = name[period+1:]
-	}
-	name = bytes.Replace(name, centerDot, dot, -1)
-	return name
-}
-
-// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
-// While Martini is in development mode, Recovery will also output the panic as HTML.
-func Recovery() Handler {
-	return func(c Context, log *log.Logger) {
-		defer func() {
-			if err := recover(); err != nil {
-				stack := stack(3)
-				log.Printf("PANIC: %s\n%s", err, stack)
-
-				// Lookup the current responsewriter
-				val := c.Get(inject.InterfaceOf((*http.ResponseWriter)(nil)))
-				res := val.Interface().(http.ResponseWriter)
-
-				// respond with panic message while in development mode
-				var body []byte
-				if Env == Dev {
-					res.Header().Set("Content-Type", "text/html")
-					body = []byte(fmt.Sprintf(panicHtml, err, err, stack))
-				} else {
-					body = []byte("500 Internal Server Error")
-				}
-
-				res.WriteHeader(http.StatusInternalServerError)
-				if nil != body {
-					res.Write(body)
-				}
-			}
-		}()
-
-		c.Next()
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/recovery_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/recovery_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/recovery_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/recovery_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,49 +0,0 @@
-package martini
-
-import (
-	"bytes"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func Test_Recovery(t *testing.T) {
-	buff := bytes.NewBufferString("")
-	recorder := httptest.NewRecorder()
-
-	setENV(Dev)
-	m := New()
-	// replace log for testing
-	m.Map(log.New(buff, "[martini] ", 0))
-	m.Use(func(res http.ResponseWriter, req *http.Request) {
-		res.Header().Set("Content-Type", "unpredictable")
-	})
-	m.Use(Recovery())
-	m.Use(func(res http.ResponseWriter, req *http.Request) {
-		panic("here is a panic!")
-	})
-	m.ServeHTTP(recorder, (*http.Request)(nil))
-	expect(t, recorder.Code, http.StatusInternalServerError)
-	expect(t, recorder.HeaderMap.Get("Content-Type"), "text/html")
-	refute(t, recorder.Body.Len(), 0)
-	refute(t, len(buff.String()), 0)
-}
-
-func Test_Recovery_ResponseWriter(t *testing.T) {
-	recorder := httptest.NewRecorder()
-	recorder2 := httptest.NewRecorder()
-
-	setENV(Dev)
-	m := New()
-	m.Use(Recovery())
-	m.Use(func(c Context) {
-		c.MapTo(recorder2, (*http.ResponseWriter)(nil))
-		panic("here is a panic!")
-	})
-	m.ServeHTTP(recorder, (*http.Request)(nil))
-
-	expect(t, recorder2.Code, http.StatusInternalServerError)
-	expect(t, recorder2.HeaderMap.Get("Content-Type"), "text/html")
-	refute(t, recorder2.Body.Len(), 0)
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/response_writer.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/response_writer.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/response_writer.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/response_writer.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,107 +0,0 @@
-package martini
-
-import (
-	"bufio"
-	"fmt"
-	"net"
-	"net/http"
-)
-
-// ResponseWriter is a wrapper around http.ResponseWriter that provides extra information about
-// the response. It is recommended that middleware handlers use this construct to wrap a responsewriter
-// if the functionality calls for it.
-type ResponseWriter interface {
-	http.ResponseWriter
-	http.Flusher
-	http.Hijacker
-	// Status returns the status code of the response or 0 if the response has not been written.
-	Status() int
-	// Written returns whether or not the ResponseWriter has been written.
-	Written() bool
-	// Size returns the size of the response body.
-	Size() int
-	// Before allows for a function to be called before the ResponseWriter has been written to. This is
-	// useful for setting headers or any other operations that must happen before a response has been written.
-	Before(BeforeFunc)
-}
-
-// BeforeFunc is a function that is called before the ResponseWriter has been written to.
-type BeforeFunc func(ResponseWriter)
-
-// NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter
-func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
-	newRw := responseWriter{rw, 0, 0, nil}
-	if cn, ok := rw.(http.CloseNotifier); ok {
-		return &closeNotifyResponseWriter{newRw, cn}
-	}
-	return &newRw
-}
-
-type responseWriter struct {
-	http.ResponseWriter
-	status      int
-	size        int
-	beforeFuncs []BeforeFunc
-}
-
-func (rw *responseWriter) WriteHeader(s int) {
-	rw.callBefore()
-	rw.ResponseWriter.WriteHeader(s)
-	rw.status = s
-}
-
-func (rw *responseWriter) Write(b []byte) (int, error) {
-	if !rw.Written() {
-		// The status will be StatusOK if WriteHeader has not been called yet
-		rw.WriteHeader(http.StatusOK)
-	}
-	size, err := rw.ResponseWriter.Write(b)
-	rw.size += size
-	return size, err
-}
-
-func (rw *responseWriter) Status() int {
-	return rw.status
-}
-
-func (rw *responseWriter) Size() int {
-	return rw.size
-}
-
-func (rw *responseWriter) Written() bool {
-	return rw.status != 0
-}
-
-func (rw *responseWriter) Before(before BeforeFunc) {
-	rw.beforeFuncs = append(rw.beforeFuncs, before)
-}
-
-func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	hijacker, ok := rw.ResponseWriter.(http.Hijacker)
-	if !ok {
-		return nil, nil, fmt.Errorf("the ResponseWriter doesn't support the Hijacker interface")
-	}
-	return hijacker.Hijack()
-}
-
-func (rw *responseWriter) callBefore() {
-	for i := len(rw.beforeFuncs) - 1; i >= 0; i-- {
-		rw.beforeFuncs[i](rw)
-	}
-}
-
-func (rw *responseWriter) Flush() {
-	flusher, ok := rw.ResponseWriter.(http.Flusher)
-	if ok {
-		flusher.Flush()
-	}
-}
-
-type closeNotifyResponseWriter struct {
-	responseWriter
-	closeNotifier http.CloseNotifier
-}
-
-func (rw *closeNotifyResponseWriter) CloseNotify() <-chan bool {
-	return rw.closeNotifier.CloseNotify()
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/response_writer_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/response_writer_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/response_writer_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/response_writer_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,188 +0,0 @@
-package martini
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-)
-
-type closeNotifyingRecorder struct {
-	*httptest.ResponseRecorder
-	closed chan bool
-}
-
-func newCloseNotifyingRecorder() *closeNotifyingRecorder {
-	return &closeNotifyingRecorder{
-		httptest.NewRecorder(),
-		make(chan bool, 1),
-	}
-}
-
-func (c *closeNotifyingRecorder) close() {
-	c.closed <- true
-}
-
-func (c *closeNotifyingRecorder) CloseNotify() <-chan bool {
-	return c.closed
-}
-
-type hijackableResponse struct {
-	Hijacked bool
-}
-
-func newHijackableResponse() *hijackableResponse {
-	return &hijackableResponse{}
-}
-
-func (h *hijackableResponse) Header() http.Header           { return nil }
-func (h *hijackableResponse) Write(buf []byte) (int, error) { return 0, nil }
-func (h *hijackableResponse) WriteHeader(code int)          {}
-func (h *hijackableResponse) Flush()                        {}
-func (h *hijackableResponse) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	h.Hijacked = true
-	return nil, nil, nil
-}
-
-func Test_ResponseWriter_WritingString(t *testing.T) {
-	rec := httptest.NewRecorder()
-	rw := NewResponseWriter(rec)
-
-	rw.Write([]byte("Hello world"))
-
-	expect(t, rec.Code, rw.Status())
-	expect(t, rec.Body.String(), "Hello world")
-	expect(t, rw.Status(), http.StatusOK)
-	expect(t, rw.Size(), 11)
-	expect(t, rw.Written(), true)
-}
-
-func Test_ResponseWriter_WritingStrings(t *testing.T) {
-	rec := httptest.NewRecorder()
-	rw := NewResponseWriter(rec)
-
-	rw.Write([]byte("Hello world"))
-	rw.Write([]byte("foo bar bat baz"))
-
-	expect(t, rec.Code, rw.Status())
-	expect(t, rec.Body.String(), "Hello worldfoo bar bat baz")
-	expect(t, rw.Status(), http.StatusOK)
-	expect(t, rw.Size(), 26)
-}
-
-func Test_ResponseWriter_WritingHeader(t *testing.T) {
-	rec := httptest.NewRecorder()
-	rw := NewResponseWriter(rec)
-
-	rw.WriteHeader(http.StatusNotFound)
-
-	expect(t, rec.Code, rw.Status())
-	expect(t, rec.Body.String(), "")
-	expect(t, rw.Status(), http.StatusNotFound)
-	expect(t, rw.Size(), 0)
-}
-
-func Test_ResponseWriter_Before(t *testing.T) {
-	rec := httptest.NewRecorder()
-	rw := NewResponseWriter(rec)
-	result := ""
-
-	rw.Before(func(ResponseWriter) {
-		result += "foo"
-	})
-	rw.Before(func(ResponseWriter) {
-		result += "bar"
-	})
-
-	rw.WriteHeader(http.StatusNotFound)
-
-	expect(t, rec.Code, rw.Status())
-	expect(t, rec.Body.String(), "")
-	expect(t, rw.Status(), http.StatusNotFound)
-	expect(t, rw.Size(), 0)
-	expect(t, result, "barfoo")
-}
-
-func Test_ResponseWriter_Hijack(t *testing.T) {
-	hijackable := newHijackableResponse()
-	rw := NewResponseWriter(hijackable)
-	hijacker, ok := rw.(http.Hijacker)
-	expect(t, ok, true)
-	_, _, err := hijacker.Hijack()
-	if err != nil {
-		t.Error(err)
-	}
-	expect(t, hijackable.Hijacked, true)
-}
-
-func Test_ResponseWrite_Hijack_NotOK(t *testing.T) {
-	hijackable := new(http.ResponseWriter)
-	rw := NewResponseWriter(*hijackable)
-	hijacker, ok := rw.(http.Hijacker)
-	expect(t, ok, true)
-	_, _, err := hijacker.Hijack()
-
-	refute(t, err, nil)
-}
-
-func Test_ResponseWriter_CloseNotify(t *testing.T) {
-	rec := newCloseNotifyingRecorder()
-	rw := NewResponseWriter(rec)
-	closed := false
-	notifier := rw.(http.CloseNotifier).CloseNotify()
-	rec.close()
-	select {
-	case <-notifier:
-		closed = true
-	case <-time.After(time.Second):
-	}
-	expect(t, closed, true)
-}
-
-func Test_ResponseWriter_Flusher(t *testing.T) {
-
-	rec := httptest.NewRecorder()
-	rw := NewResponseWriter(rec)
-
-	_, ok := rw.(http.Flusher)
-	expect(t, ok, true)
-}
-
-func Test_ResponseWriter_FlusherHandler(t *testing.T) {
-
-	// New martini instance
-	m := Classic()
-
-	m.Get("/events", func(w http.ResponseWriter, r *http.Request) {
-
-		f, ok := w.(http.Flusher)
-		expect(t, ok, true)
-
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.Header().Set("Cache-Control", "no-cache")
-		w.Header().Set("Connection", "keep-alive")
-
-		for i := 0; i < 2; i++ {
-			time.Sleep(10 * time.Millisecond)
-			io.WriteString(w, "data: Hello\n\n")
-			f.Flush()
-		}
-
-	})
-
-	recorder := httptest.NewRecorder()
-	r, _ := http.NewRequest("GET", "/events", nil)
-	m.ServeHTTP(recorder, r)
-
-	if recorder.Code != 200 {
-		t.Error("Response not 200")
-	}
-
-	if recorder.Body.String() != "data: Hello\n\ndata: Hello\n\n" {
-		t.Error("Didn't receive correct body, got:", recorder.Body.String())
-	}
-
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/return_handler.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/return_handler.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/return_handler.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/return_handler.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,43 +0,0 @@
-package martini
-
-import (
-	"github.com/codegangsta/inject"
-	"net/http"
-	"reflect"
-)
-
-// ReturnHandler is a service that Martini provides that is called
-// when a route handler returns something. The ReturnHandler is
-// responsible for writing to the ResponseWriter based on the values
-// that are passed into this function.
-type ReturnHandler func(Context, []reflect.Value)
-
-func defaultReturnHandler() ReturnHandler {
-	return func(ctx Context, vals []reflect.Value) {
-		rv := ctx.Get(inject.InterfaceOf((*http.ResponseWriter)(nil)))
-		res := rv.Interface().(http.ResponseWriter)
-		var responseVal reflect.Value
-		if len(vals) > 1 && vals[0].Kind() == reflect.Int {
-			res.WriteHeader(int(vals[0].Int()))
-			responseVal = vals[1]
-		} else if len(vals) > 0 {
-			responseVal = vals[0]
-		}
-		if canDeref(responseVal) {
-			responseVal = responseVal.Elem()
-		}
-		if isByteSlice(responseVal) {
-			res.Write(responseVal.Bytes())
-		} else {
-			res.Write([]byte(responseVal.String()))
-		}
-	}
-}
-
-func isByteSlice(val reflect.Value) bool {
-	return val.Kind() == reflect.Slice && val.Type().Elem().Kind() == reflect.Uint8
-}
-
-func canDeref(val reflect.Value) bool {
-	return val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/router.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/router.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/router.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/router.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,425 +0,0 @@
-package martini
-
-import (
-	"fmt"
-	"net/http"
-	"reflect"
-	"regexp"
-	"strconv"
-	"sync"
-)
-
-// Params is a map of name/value pairs for named routes. An instance of martini.Params is available to be injected into any route handler.
-type Params map[string]string
-
-// Router is Martini's de-facto routing interface. Supports HTTP verbs, stacked handlers, and dependency injection.
-type Router interface {
-	Routes
-
-	// Group adds a group where related routes can be added.
-	Group(string, func(Router), ...Handler)
-	// Get adds a route for a HTTP GET request to the specified matching pattern.
-	Get(string, ...Handler) Route
-	// Patch adds a route for a HTTP PATCH request to the specified matching pattern.
-	Patch(string, ...Handler) Route
-	// Post adds a route for a HTTP POST request to the specified matching pattern.
-	Post(string, ...Handler) Route
-	// Put adds a route for a HTTP PUT request to the specified matching pattern.
-	Put(string, ...Handler) Route
-	// Delete adds a route for a HTTP DELETE request to the specified matching pattern.
-	Delete(string, ...Handler) Route
-	// Options adds a route for a HTTP OPTIONS request to the specified matching pattern.
-	Options(string, ...Handler) Route
-	// Head adds a route for a HTTP HEAD request to the specified matching pattern.
-	Head(string, ...Handler) Route
-	// Any adds a route for any HTTP method request to the specified matching pattern.
-	Any(string, ...Handler) Route
-	// AddRoute adds a route for a given HTTP method request to the specified matching pattern.
-	AddRoute(string, string, ...Handler) Route
-
-	// NotFound sets the handlers that are called when a no route matches a request. Throws a basic 404 by default.
-	NotFound(...Handler)
-
-	// Handle is the entry point for routing. This is used as a martini.Handler
-	Handle(http.ResponseWriter, *http.Request, Context)
-}
-
-type router struct {
-	routes     []*route
-	notFounds  []Handler
-	groups     []group
-	routesLock sync.RWMutex
-}
-
-type group struct {
-	pattern  string
-	handlers []Handler
-}
-
-// NewRouter creates a new Router instance.
-// If you aren't using ClassicMartini, then you can add Routes as a
-// service with:
-//
-//	m := martini.New()
-//	r := martini.NewRouter()
-//	m.MapTo(r, (*martini.Routes)(nil))
-//
-// If you are using ClassicMartini, then this is done for you.
-func NewRouter() Router {
-	return &router{notFounds: []Handler{http.NotFound}, groups: make([]group, 0)}
-}
-
-func (r *router) Group(pattern string, fn func(Router), h ...Handler) {
-	r.groups = append(r.groups, group{pattern, h})
-	fn(r)
-	r.groups = r.groups[:len(r.groups)-1]
-}
-
-func (r *router) Get(pattern string, h ...Handler) Route {
-	return r.addRoute("GET", pattern, h)
-}
-
-func (r *router) Patch(pattern string, h ...Handler) Route {
-	return r.addRoute("PATCH", pattern, h)
-}
-
-func (r *router) Post(pattern string, h ...Handler) Route {
-	return r.addRoute("POST", pattern, h)
-}
-
-func (r *router) Put(pattern string, h ...Handler) Route {
-	return r.addRoute("PUT", pattern, h)
-}
-
-func (r *router) Delete(pattern string, h ...Handler) Route {
-	return r.addRoute("DELETE", pattern, h)
-}
-
-func (r *router) Options(pattern string, h ...Handler) Route {
-	return r.addRoute("OPTIONS", pattern, h)
-}
-
-func (r *router) Head(pattern string, h ...Handler) Route {
-	return r.addRoute("HEAD", pattern, h)
-}
-
-func (r *router) Any(pattern string, h ...Handler) Route {
-	return r.addRoute("*", pattern, h)
-}
-
-func (r *router) AddRoute(method, pattern string, h ...Handler) Route {
-	return r.addRoute(method, pattern, h)
-}
-
-func (r *router) Handle(res http.ResponseWriter, req *http.Request, context Context) {
-	bestMatch := NoMatch
-	var bestVals map[string]string
-	var bestRoute *route
-	for _, route := range r.getRoutes() {
-		match, vals := route.Match(req.Method, req.URL.Path)
-		if match.BetterThan(bestMatch) {
-			bestMatch = match
-			bestVals = vals
-			bestRoute = route
-			if match == ExactMatch {
-				break
-			}
-		}
-	}
-	if bestMatch != NoMatch {
-		params := Params(bestVals)
-		context.Map(params)
-		bestRoute.Handle(context, res)
-		return
-	}
-
-	// no routes exist, 404
-	c := &routeContext{context, 0, r.notFounds}
-	context.MapTo(c, (*Context)(nil))
-	c.run()
-}
-
-func (r *router) NotFound(handler ...Handler) {
-	r.notFounds = handler
-}
-
-func (r *router) addRoute(method string, pattern string, handlers []Handler) *route {
-	if len(r.groups) > 0 {
-		groupPattern := ""
-		h := make([]Handler, 0)
-		for _, g := range r.groups {
-			groupPattern += g.pattern
-			h = append(h, g.handlers...)
-		}
-
-		pattern = groupPattern + pattern
-		h = append(h, handlers...)
-		handlers = h
-	}
-
-	route := newRoute(method, pattern, handlers)
-	route.Validate()
-	r.appendRoute(route)
-	return route
-}
-
-func (r *router) appendRoute(rt *route) {
-	r.routesLock.Lock()
-	defer r.routesLock.Unlock()
-	r.routes = append(r.routes, rt)
-}
-
-func (r *router) getRoutes() []*route {
-	r.routesLock.RLock()
-	defer r.routesLock.RUnlock()
-	return r.routes[:]
-}
-
-func (r *router) findRoute(name string) *route {
-	for _, route := range r.getRoutes() {
-		if route.name == name {
-			return route
-		}
-	}
-
-	return nil
-}
-
-// Route is an interface representing a Route in Martini's routing layer.
-type Route interface {
-	// URLWith returns a rendering of the Route's url with the given string params.
-	URLWith([]string) string
-	// Name sets a name for the route.
-	Name(string)
-	// GetName returns the name of the route.
-	GetName() string
-	// Pattern returns the pattern of the route.
-	Pattern() string
-	// Method returns the method of the route.
-	Method() string
-}
-
-type route struct {
-	method   string
-	regex    *regexp.Regexp
-	handlers []Handler
-	pattern  string
-	name     string
-}
-
-var routeReg1 = regexp.MustCompile(`:[^/#?()\.\\]+`)
-var routeReg2 = regexp.MustCompile(`\*\*`)
-
-func newRoute(method string, pattern string, handlers []Handler) *route {
-	route := route{method, nil, handlers, pattern, ""}
-	pattern = routeReg1.ReplaceAllStringFunc(pattern, func(m string) string {
-		return fmt.Sprintf(`(?P<%s>[^/#?]+)`, m[1:])
-	})
-	var index int
-	pattern = routeReg2.ReplaceAllStringFunc(pattern, func(m string) string {
-		index++
-		return fmt.Sprintf(`(?P<_%d>[^#?]*)`, index)
-	})
-	pattern += `\/?`
-	route.regex = regexp.MustCompile(pattern)
-	return &route
-}
-
-type RouteMatch int
-
-const (
-	NoMatch RouteMatch = iota
-	StarMatch
-	OverloadMatch
-	ExactMatch
-)
-
-//Higher number = better match
-func (r RouteMatch) BetterThan(o RouteMatch) bool {
-	return r > o
-}
-
-func (r route) MatchMethod(method string) RouteMatch {
-	switch {
-	case method == r.method:
-		return ExactMatch
-	case method == "HEAD" && r.method == "GET":
-		return OverloadMatch
-	case r.method == "*":
-		return StarMatch
-	default:
-		return NoMatch
-	}
-}
-
-func (r route) Match(method string, path string) (RouteMatch, map[string]string) {
-	// add Any method matching support
-	match := r.MatchMethod(method)
-	if match == NoMatch {
-		return match, nil
-	}
-
-	matches := r.regex.FindStringSubmatch(path)
-	if len(matches) > 0 && matches[0] == path {
-		params := make(map[string]string)
-		for i, name := range r.regex.SubexpNames() {
-			if len(name) > 0 {
-				params[name] = matches[i]
-			}
-		}
-		return match, params
-	}
-	return NoMatch, nil
-}
-
-func (r *route) Validate() {
-	for _, handler := range r.handlers {
-		validateHandler(handler)
-	}
-}
-
-func (r *route) Handle(c Context, res http.ResponseWriter) {
-	context := &routeContext{c, 0, r.handlers}
-	c.MapTo(context, (*Context)(nil))
-	c.MapTo(r, (*Route)(nil))
-	context.run()
-}
-
-var urlReg = regexp.MustCompile(`:[^/#?()\.\\]+|\(\?P<[a-zA-Z0-9]+>.*\)`)
-
-// URLWith returns the url pattern replacing the parameters for its values
-func (r *route) URLWith(args []string) string {
-	if len(args) > 0 {
-		argCount := len(args)
-		i := 0
-		url := urlReg.ReplaceAllStringFunc(r.pattern, func(m string) string {
-			var val interface{}
-			if i < argCount {
-				val = args[i]
-			} else {
-				val = m
-			}
-			i += 1
-			return fmt.Sprintf(`%v`, val)
-		})
-
-		return url
-	}
-	return r.pattern
-}
-
-func (r *route) Name(name string) {
-	r.name = name
-}
-
-func (r *route) GetName() string {
-	return r.name
-}
-
-func (r *route) Pattern() string {
-	return r.pattern
-}
-
-func (r *route) Method() string {
-	return r.method
-}
-
-// Routes is a helper service for Martini's routing layer.
-type Routes interface {
-	// URLFor returns a rendered URL for the given route. Optional params can be passed to fulfill named parameters in the route.
-	URLFor(name string, params ...interface{}) string
-	// MethodsFor returns an array of methods available for the path
-	MethodsFor(path string) []string
-	// All returns an array with all the routes in the router.
-	All() []Route
-}
-
-// URLFor returns the url for the given route name.
-func (r *router) URLFor(name string, params ...interface{}) string {
-	route := r.findRoute(name)
-
-	if route == nil {
-		panic("route not found")
-	}
-
-	var args []string
-	for _, param := range params {
-		switch v := param.(type) {
-		case int:
-			args = append(args, strconv.FormatInt(int64(v), 10))
-		case string:
-			args = append(args, v)
-		default:
-			if v != nil {
-				panic("Arguments passed to URLFor must be integers or strings")
-			}
-		}
-	}
-
-	return route.URLWith(args)
-}
-
-func (r *router) All() []Route {
-	routes := r.getRoutes()
-	var ri = make([]Route, len(routes))
-
-	for i, route := range routes {
-		ri[i] = Route(route)
-	}
-
-	return ri
-}
-
-func hasMethod(methods []string, method string) bool {
-	for _, v := range methods {
-		if v == method {
-			return true
-		}
-	}
-	return false
-}
-
-// MethodsFor returns all methods available for path
-func (r *router) MethodsFor(path string) []string {
-	methods := []string{}
-	for _, route := range r.getRoutes() {
-		matches := route.regex.FindStringSubmatch(path)
-		if len(matches) > 0 && matches[0] == path && !hasMethod(methods, route.method) {
-			methods = append(methods, route.method)
-		}
-	}
-	return methods
-}
-
-type routeContext struct {
-	Context
-	index    int
-	handlers []Handler
-}
-
-func (r *routeContext) Next() {
-	r.index += 1
-	r.run()
-}
-
-func (r *routeContext) run() {
-	for r.index < len(r.handlers) {
-		handler := r.handlers[r.index]
-		vals, err := r.Invoke(handler)
-		if err != nil {
-			panic(err)
-		}
-		r.index += 1
-
-		// if the handler returned something, write it to the http response
-		if len(vals) > 0 {
-			ev := r.Get(reflect.TypeOf(ReturnHandler(nil)))
-			handleReturn := ev.Interface().(ReturnHandler)
-			handleReturn(r, vals)
-		}
-
-		if r.Written() {
-			return
-		}
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/router_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/router_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/router_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/router_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,469 +0,0 @@
-package martini
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func Test_Routing(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-
-	req2, _ := http.NewRequest("POST", "http://localhost:3000/bar/bat", nil)
-	context2 := New().createContext(recorder, req2)
-
-	req3, _ := http.NewRequest("DELETE", "http://localhost:3000/baz", nil)
-	context3 := New().createContext(recorder, req3)
-
-	req4, _ := http.NewRequest("PATCH", "http://localhost:3000/bar/foo", nil)
-	context4 := New().createContext(recorder, req4)
-
-	req5, _ := http.NewRequest("GET", "http://localhost:3000/fez/this/should/match", nil)
-	context5 := New().createContext(recorder, req5)
-
-	req6, _ := http.NewRequest("PUT", "http://localhost:3000/pop/blah/blah/blah/bap/foo/", nil)
-	context6 := New().createContext(recorder, req6)
-
-	req7, _ := http.NewRequest("DELETE", "http://localhost:3000/wap//pow", nil)
-	context7 := New().createContext(recorder, req7)
-
-	req8, _ := http.NewRequest("HEAD", "http://localhost:3000/wap//pow", nil)
-	context8 := New().createContext(recorder, req8)
-
-	req9, _ := http.NewRequest("OPTIONS", "http://localhost:3000/opts", nil)
-	context9 := New().createContext(recorder, req9)
-
-	req10, _ := http.NewRequest("HEAD", "http://localhost:3000/foo", nil)
-	context10 := New().createContext(recorder, req10)
-
-	req11, _ := http.NewRequest("GET", "http://localhost:3000/bazz/inga", nil)
-	context11 := New().createContext(recorder, req11)
-
-	req12, _ := http.NewRequest("POST", "http://localhost:3000/bazz/inga", nil)
-	context12 := New().createContext(recorder, req12)
-
-	req13, _ := http.NewRequest("GET", "http://localhost:3000/bazz/in/ga", nil)
-	context13 := New().createContext(recorder, req13)
-
-	req14, _ := http.NewRequest("GET", "http://localhost:3000/bzz", nil)
-	context14 := New().createContext(recorder, req14)
-
-	result := ""
-	router.Get("/foo", func(req *http.Request) {
-		result += "foo"
-	})
-	router.Patch("/bar/:id", func(params Params) {
-		expect(t, params["id"], "foo")
-		result += "barfoo"
-	})
-	router.Post("/bar/:id", func(params Params) {
-		expect(t, params["id"], "bat")
-		result += "barbat"
-	})
-	router.Put("/fizzbuzz", func() {
-		result += "fizzbuzz"
-	})
-	router.Delete("/bazzer", func(c Context) {
-		result += "baz"
-	})
-	router.Get("/fez/**", func(params Params) {
-		expect(t, params["_1"], "this/should/match")
-		result += "fez"
-	})
-	router.Put("/pop/**/bap/:id/**", func(params Params) {
-		expect(t, params["id"], "foo")
-		expect(t, params["_1"], "blah/blah/blah")
-		expect(t, params["_2"], "")
-		result += "popbap"
-	})
-	router.Delete("/wap/**/pow", func(params Params) {
-		expect(t, params["_1"], "")
-		result += "wappow"
-	})
-	router.Options("/opts", func() {
-		result += "opts"
-	})
-	router.Head("/wap/**/pow", func(params Params) {
-		expect(t, params["_1"], "")
-		result += "wappow"
-	})
-	router.Group("/bazz", func(r Router) {
-		r.Get("/inga", func() {
-			result += "get"
-		})
-
-		r.Post("/inga", func() {
-			result += "post"
-		})
-
-		r.Group("/in", func(r Router) {
-			r.Get("/ga", func() {
-				result += "ception"
-			})
-		}, func() {
-			result += "group"
-		})
-	}, func() {
-		result += "bazz"
-	}, func() {
-		result += "inga"
-	})
-	router.AddRoute("GET", "/bzz", func(c Context) {
-		result += "bzz"
-	})
-
-	router.Handle(recorder, req, context)
-	router.Handle(recorder, req2, context2)
-	router.Handle(recorder, req3, context3)
-	router.Handle(recorder, req4, context4)
-	router.Handle(recorder, req5, context5)
-	router.Handle(recorder, req6, context6)
-	router.Handle(recorder, req7, context7)
-	router.Handle(recorder, req8, context8)
-	router.Handle(recorder, req9, context9)
-	router.Handle(recorder, req10, context10)
-	router.Handle(recorder, req11, context11)
-	router.Handle(recorder, req12, context12)
-	router.Handle(recorder, req13, context13)
-	router.Handle(recorder, req14, context14)
-	expect(t, result, "foobarbatbarfoofezpopbapwappowwappowoptsfoobazzingagetbazzingapostbazzingagroupceptionbzz")
-	expect(t, recorder.Code, http.StatusNotFound)
-	expect(t, recorder.Body.String(), "404 page not found\n")
-}
-
-func Test_RouterHandlerStatusCode(t *testing.T) {
-	router := NewRouter()
-	router.Get("/foo", func() string {
-		return "foo"
-	})
-	router.Get("/bar", func() (int, string) {
-		return http.StatusForbidden, "bar"
-	})
-	router.Get("/baz", func() (string, string) {
-		return "baz", "BAZ!"
-	})
-	router.Get("/bytes", func() []byte {
-		return []byte("Bytes!")
-	})
-	router.Get("/interface", func() interface{} {
-		return "Interface!"
-	})
-
-	// code should be 200 if none is returned from the handler
-	recorder := httptest.NewRecorder()
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "foo")
-
-	// if a status code is returned, it should be used
-	recorder = httptest.NewRecorder()
-	req, _ = http.NewRequest("GET", "http://localhost:3000/bar", nil)
-	context = New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusForbidden)
-	expect(t, recorder.Body.String(), "bar")
-
-	// shouldn't use the first returned value as a status code if not an integer
-	recorder = httptest.NewRecorder()
-	req, _ = http.NewRequest("GET", "http://localhost:3000/baz", nil)
-	context = New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "baz")
-
-	// Should render bytes as a return value as well.
-	recorder = httptest.NewRecorder()
-	req, _ = http.NewRequest("GET", "http://localhost:3000/bytes", nil)
-	context = New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "Bytes!")
-
-	// Should render interface{} values.
-	recorder = httptest.NewRecorder()
-	req, _ = http.NewRequest("GET", "http://localhost:3000/interface", nil)
-	context = New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "Interface!")
-}
-
-func Test_RouterHandlerStacking(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-
-	result := ""
-
-	f1 := func() {
-		result += "foo"
-	}
-
-	f2 := func(c Context) {
-		result += "bar"
-		c.Next()
-		result += "bing"
-	}
-
-	f3 := func() string {
-		result += "bat"
-		return "Hello world"
-	}
-
-	f4 := func() {
-		result += "baz"
-	}
-
-	router.Get("/foo", f1, f2, f3, f4)
-
-	router.Handle(recorder, req, context)
-	expect(t, result, "foobarbatbing")
-	expect(t, recorder.Body.String(), "Hello world")
-}
-
-var routeTests = []struct {
-	// in
-	method string
-	path   string
-
-	// out
-	match  RouteMatch
-	params map[string]string
-}{
-	{"GET", "/foo/123/bat/321", ExactMatch, map[string]string{"bar": "123", "baz": "321"}},
-	{"POST", "/foo/123/bat/321", NoMatch, map[string]string{}},
-	{"GET", "/foo/hello/bat/world", ExactMatch, map[string]string{"bar": "hello", "baz": "world"}},
-	{"GET", "foo/hello/bat/world", NoMatch, map[string]string{}},
-	{"GET", "/foo/123/bat/321/", ExactMatch, map[string]string{"bar": "123", "baz": "321"}},
-	{"GET", "/foo/123/bat/321//", NoMatch, map[string]string{}},
-	{"GET", "/foo/123//bat/321/", NoMatch, map[string]string{}},
-	{"HEAD", "/foo/123/bat/321/", OverloadMatch, map[string]string{"bar": "123", "baz": "321"}},
-}
-
-func Test_RouteMatching(t *testing.T) {
-	route := newRoute("GET", "/foo/:bar/bat/:baz", nil)
-	for _, tt := range routeTests {
-		match, params := route.Match(tt.method, tt.path)
-		if match != tt.match || params["bar"] != tt.params["bar"] || params["baz"] != tt.params["baz"] {
-			t.Errorf("expected: (%v, %v) got: (%v, %v)", tt.match, tt.params, match, params)
-		}
-	}
-}
-
-func Test_MethodsFor(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("POST", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-	context.MapTo(router, (*Routes)(nil))
-	router.Post("/foo/bar", func() {
-	})
-
-	router.Post("/fo", func() {
-	})
-
-	router.Get("/foo", func() {
-	})
-
-	router.Put("/foo", func() {
-	})
-
-	router.NotFound(func(routes Routes, w http.ResponseWriter, r *http.Request) {
-		methods := routes.MethodsFor(r.URL.Path)
-		if len(methods) != 0 {
-			w.Header().Set("Allow", strings.Join(methods, ","))
-			w.WriteHeader(http.StatusMethodNotAllowed)
-		}
-	})
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusMethodNotAllowed)
-	expect(t, recorder.Header().Get("Allow"), "GET,PUT")
-}
-
-func Test_NotFound(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-
-	router.NotFound(func(res http.ResponseWriter) {
-		http.Error(res, "Nope", http.StatusNotFound)
-	})
-
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusNotFound)
-	expect(t, recorder.Body.String(), "Nope\n")
-}
-
-func Test_NotFoundAsHandler(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-
-	router.NotFound(func() string {
-		return "not found"
-	})
-
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "not found")
-
-	recorder = httptest.NewRecorder()
-
-	context = New().createContext(recorder, req)
-
-	router.NotFound(func() (int, string) {
-		return 404, "not found"
-	})
-
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusNotFound)
-	expect(t, recorder.Body.String(), "not found")
-
-	recorder = httptest.NewRecorder()
-
-	context = New().createContext(recorder, req)
-
-	router.NotFound(func() (int, string) {
-		return 200, ""
-	})
-
-	router.Handle(recorder, req, context)
-	expect(t, recorder.Code, http.StatusOK)
-	expect(t, recorder.Body.String(), "")
-}
-
-func Test_NotFoundStacking(t *testing.T) {
-	router := NewRouter()
-	recorder := httptest.NewRecorder()
-
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-
-	result := ""
-
-	f1 := func() {
-		result += "foo"
-	}
-
-	f2 := func(c Context) {
-		result += "bar"
-		c.Next()
-		result += "bing"
-	}
-
-	f3 := func() string {
-		result += "bat"
-		return "Not Found"
-	}
-
-	f4 := func() {
-		result += "baz"
-	}
-
-	router.NotFound(f1, f2, f3, f4)
-
-	router.Handle(recorder, req, context)
-	expect(t, result, "foobarbatbing")
-	expect(t, recorder.Body.String(), "Not Found")
-}
-
-func Test_Any(t *testing.T) {
-	router := NewRouter()
-	router.Any("/foo", func(res http.ResponseWriter) {
-		http.Error(res, "Nope", http.StatusNotFound)
-	})
-
-	recorder := httptest.NewRecorder()
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-
-	expect(t, recorder.Code, http.StatusNotFound)
-	expect(t, recorder.Body.String(), "Nope\n")
-
-	recorder = httptest.NewRecorder()
-	req, _ = http.NewRequest("PUT", "http://localhost:3000/foo", nil)
-	context = New().createContext(recorder, req)
-	router.Handle(recorder, req, context)
-
-	expect(t, recorder.Code, http.StatusNotFound)
-	expect(t, recorder.Body.String(), "Nope\n")
-}
-
-func Test_URLFor(t *testing.T) {
-	router := NewRouter()
-
-	router.Get("/foo", func() {
-		// Nothing
-	}).Name("foo")
-
-	router.Post("/bar/:id", func(params Params) {
-		// Nothing
-	}).Name("bar")
-
-	router.Get("/baz/:id/(?P<name>[a-z]*)", func(params Params, routes Routes) {
-		// Nothing
-	}).Name("baz_id")
-
-	router.Get("/bar/:id/:name", func(params Params, routes Routes) {
-		expect(t, routes.URLFor("foo", nil), "/foo")
-		expect(t, routes.URLFor("bar", 5), "/bar/5")
-		expect(t, routes.URLFor("baz_id", 5, "john"), "/baz/5/john")
-		expect(t, routes.URLFor("bar_id", 5, "john"), "/bar/5/john")
-	}).Name("bar_id")
-
-	// code should be 200 if none is returned from the handler
-	recorder := httptest.NewRecorder()
-	req, _ := http.NewRequest("GET", "http://localhost:3000/bar/foo/bar", nil)
-	context := New().createContext(recorder, req)
-	context.MapTo(router, (*Routes)(nil))
-	router.Handle(recorder, req, context)
-}
-
-func Test_AllRoutes(t *testing.T) {
-	router := NewRouter()
-
-	patterns := []string{"/foo", "/fee", "/fii"}
-	methods := []string{"GET", "POST", "DELETE"}
-	names := []string{"foo", "fee", "fii"}
-
-	router.Get("/foo", func() {}).Name("foo")
-	router.Post("/fee", func() {}).Name("fee")
-	router.Delete("/fii", func() {}).Name("fii")
-
-	for i, r := range router.All() {
-		expect(t, r.Pattern(), patterns[i])
-		expect(t, r.Method(), methods[i])
-		expect(t, r.GetName(), names[i])
-	}
-}
-
-func Test_ActiveRoute(t *testing.T) {
-	router := NewRouter()
-
-	router.Get("/foo", func(r Route) {
-		expect(t, r.Pattern(), "/foo")
-		expect(t, r.GetName(), "foo")
-	}).Name("foo")
-
-	// code should be 200 if none is returned from the handler
-	recorder := httptest.NewRecorder()
-	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
-	context := New().createContext(recorder, req)
-	context.MapTo(router, (*Routes)(nil))
-	router.Handle(recorder, req, context)
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/static.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/static.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/static.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/static.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,135 +0,0 @@
-package martini
-
-import (
-	"log"
-	"net/http"
-	"net/url"
-	"path"
-	"path/filepath"
-	"strings"
-)
-
-// StaticOptions is a struct for specifying configuration options for the martini.Static middleware.
-type StaticOptions struct {
-	// Prefix is the optional prefix used to serve the static directory content
-	Prefix string
-	// SkipLogging will disable [Static] log messages when a static file is served.
-	SkipLogging bool
-	// IndexFile defines which file to serve as index if it exists.
-	IndexFile string
-	// Expires defines which user-defined function to use for producing a HTTP Expires Header
-	// https://developers.google.com/speed/docs/insights/LeverageBrowserCaching
-	Expires func() string
-	// Fallback defines a default URL to serve when the requested resource was
-	// not found.
-	Fallback string
-	// Exclude defines a pattern for URLs this handler should never process.
-	Exclude string
-}
-
-func prepareStaticOptions(options []StaticOptions) StaticOptions {
-	var opt StaticOptions
-	if len(options) > 0 {
-		opt = options[0]
-	}
-
-	// Defaults
-	if len(opt.IndexFile) == 0 {
-		opt.IndexFile = "index.html"
-	}
-	// Normalize the prefix if provided
-	if opt.Prefix != "" {
-		// Ensure we have a leading '/'
-		if opt.Prefix[0] != '/' {
-			opt.Prefix = "/" + opt.Prefix
-		}
-		// Remove any trailing '/'
-		opt.Prefix = strings.TrimRight(opt.Prefix, "/")
-	}
-	return opt
-}
-
-// Static returns a middleware handler that serves static files in the given directory.
-func Static(directory string, staticOpt ...StaticOptions) Handler {
-	if !filepath.IsAbs(directory) {
-		directory = filepath.Join(Root, directory)
-	}
-	dir := http.Dir(directory)
-	opt := prepareStaticOptions(staticOpt)
-
-	return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
-		if req.Method != "GET" && req.Method != "HEAD" {
-			return
-		}
-		if opt.Exclude != "" && strings.HasPrefix(req.URL.Path, opt.Exclude) {
-			return
-		}
-		file := req.URL.Path
-		// if we have a prefix, filter requests by stripping the prefix
-		if opt.Prefix != "" {
-			if !strings.HasPrefix(file, opt.Prefix) {
-				return
-			}
-			file = file[len(opt.Prefix):]
-			if file != "" && file[0] != '/' {
-				return
-			}
-		}
-		f, err := dir.Open(file)
-		if err != nil {
-			// try any fallback before giving up
-			if opt.Fallback != "" {
-				file = opt.Fallback // so that logging stays true
-				f, err = dir.Open(opt.Fallback)
-			}
-
-			if err != nil {
-				// discard the error?
-				return
-			}
-		}
-		defer f.Close()
-
-		fi, err := f.Stat()
-		if err != nil {
-			return
-		}
-
-		// try to serve index file
-		if fi.IsDir() {
-			// redirect if missing trailing slash
-			if !strings.HasSuffix(req.URL.Path, "/") {
-				dest := url.URL{
-					Path:     req.URL.Path + "/",
-					RawQuery: req.URL.RawQuery,
-					Fragment: req.URL.Fragment,
-				}
-				http.Redirect(res, req, dest.String(), http.StatusFound)
-				return
-			}
-
-			file = path.Join(file, opt.IndexFile)
-			f, err = dir.Open(file)
-			if err != nil {
-				return
-			}
-			defer f.Close()
-
-			fi, err = f.Stat()
-			if err != nil || fi.IsDir() {
-				return
-			}
-		}
-
-		if !opt.SkipLogging {
-			log.Println("[Static] Serving " + file)
-		}
-
-		// Add an Expires header to the static content
-		if opt.Expires != nil {
-			res.Header().Set("Expires", opt.Expires())
-		}
-
-		http.ServeContent(res, req, file, fi.ModTime(), f)
-	}
-}
diff -pruN 1.7.0-1/debian/go/src/github.com/go-martini/martini/static_test.go 1.7.0-2/debian/go/src/github.com/go-martini/martini/static_test.go
--- 1.7.0-1/debian/go/src/github.com/go-martini/martini/static_test.go	2020-11-19 19:42:17.000000000 +0000
+++ 1.7.0-2/debian/go/src/github.com/go-martini/martini/static_test.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,254 +0,0 @@
-package martini
-
-import (
-	"bytes"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/codegangsta/inject"
-)
-
-var currentRoot, _ = os.Getwd()
-
-func Test_Static(t *testing.T) {
-	response := httptest.NewRecorder()
-	response.Body = new(bytes.Buffer)
-
-	m := New()
-	r := NewRouter()
-
-	m.Use(Static(currentRoot))
-	m.Action(r.Handle)
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, response.Header().Get("Expires"), "")
-	if response.Body.Len() == 0 {
-		t.Errorf("Got empty body for GET request")
-	}
-}
-
-func Test_Static_Local_Path(t *testing.T) {
-	Root = os.TempDir()
-	response := httptest.NewRecorder()
-	response.Body = new(bytes.Buffer)
-
-	m := New()
-	r := NewRouter()
-
-	m.Use(Static("."))
-	f, err := ioutil.TempFile(Root, "static_content")
-	if err != nil {
-		t.Error(err)
-	}
-	f.WriteString("Expected Content")
-	f.Close()
-	m.Action(r.Handle)
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/"+path.Base(f.Name()), nil)
-	if err != nil {
-		t.Error(err)
-	}
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, response.Header().Get("Expires"), "")
-	expect(t, response.Body.String(), "Expected Content")
-}
-
-func Test_Static_Head(t *testing.T) {
-	response := httptest.NewRecorder()
-	response.Body = new(bytes.Buffer)
-
-	m := New()
-	r := NewRouter()
-
-	m.Use(Static(currentRoot))
-	m.Action(r.Handle)
-
-	req, err := http.NewRequest("HEAD", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	if response.Body.Len() != 0 {
-		t.Errorf("Got non-empty body for HEAD request")
-	}
-}
-
-func Test_Static_As_Post(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	m := New()
-	r := NewRouter()
-
-	m.Use(Static(currentRoot))
-	m.Action(r.Handle)
-
-	req, err := http.NewRequest("POST", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusNotFound)
-}
-
-func Test_Static_BadDir(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	m := Classic()
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	refute(t, response.Code, http.StatusOK)
-}
-
-func Test_Static_Options_Logging(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	var buffer bytes.Buffer
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-
-	opt := StaticOptions{}
-	m.Use(Static(currentRoot, opt))
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
-
-	// Now without logging
-	m.Handlers()
-	buffer.Reset()
-
-	// This should disable logging
-	opt.SkipLogging = true
-	m.Use(Static(currentRoot, opt))
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, buffer.String(), "")
-}
-
-func Test_Static_Options_ServeIndex(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	var buffer bytes.Buffer
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-
-	opt := StaticOptions{IndexFile: "martini.go"} // Define martini.go as index file
-	m.Use(Static(currentRoot, opt))
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
-}
-
-func Test_Static_Options_Prefix(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	var buffer bytes.Buffer
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-
-	// Serve current directory under /public
-	m.Use(Static(currentRoot, StaticOptions{Prefix: "/public"}))
-
-	// Check file content behaviour
-	req, err := http.NewRequest("GET", "http://localhost:3000/public/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
-}
-
-func Test_Static_Options_Expires(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	var buffer bytes.Buffer
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-
-	// Serve current directory under /public
-	m.Use(Static(currentRoot, StaticOptions{Expires: func() string { return "46" }}))
-
-	// Check file content behaviour
-	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Header().Get("Expires"), "46")
-}
-
-func Test_Static_Options_Fallback(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	var buffer bytes.Buffer
-	m := &Martini{Injector: inject.New(), action: func() {}, logger: log.New(&buffer, "[martini] ", 0)}
-	m.Map(m.logger)
-	m.Map(defaultReturnHandler())
-
-	// Serve current directory under /public
-	m.Use(Static(currentRoot, StaticOptions{Fallback: "/martini.go"}))
-
-	// Check file content behaviour
-	req, err := http.NewRequest("GET", "http://localhost:3000/initram.go", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusOK)
-	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
-}
-
-func Test_Static_Redirect(t *testing.T) {
-	response := httptest.NewRecorder()
-
-	m := New()
-	m.Use(Static(currentRoot, StaticOptions{Prefix: "/public"}))
-
-	req, err := http.NewRequest("GET", "http://localhost:3000/public?param=foo#bar", nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	m.ServeHTTP(response, req)
-	expect(t, response.Code, http.StatusFound)
-	expect(t, response.Header().Get("Location"), "/public/?param=foo#bar")
-}
diff -pruN 1.7.0-1/debian/rules 1.7.0-2/debian/rules
--- 1.7.0-1/debian/rules	2020-11-21 04:40:20.000000000 +0000
+++ 1.7.0-2/debian/rules	2022-02-08 17:50:50.000000000 +0000
@@ -1,19 +1,8 @@
 #!/usr/bin/make -f
 
-## Don't build examples/revelapp due to FTBFS:
-##     src/github.com/bugsnag/bugsnag-go/examples/revelapp/tests/apptest.go:6: undefined: revel.TestSuite
-DH_GOLANG_EXCLUDES = examples/revelapp
-
-## Don't build examples/http binary:
-DH_GOLANG_EXCLUDES += examples/http
-
-export DH_GOLANG_EXCLUDES
+export DH_GOLANG_EXCLUDES := \
+	examples features \
+	gin martini negroni revel
 
 %:
 	dh $@ --builddirectory=_build --buildsystem=golang --with=golang
-
-execute_after_dh_auto_configure:
-	cp -av $(CURDIR)/debian/go/src _build/src/github.com/bugsnag/bugsnag-go/vendor
-
-override_dh_auto_install:
-	dh_auto_install -- --no-binaries