Merge lp:~kyrofa/crackly/vendor_dependencies into lp:crackly

[Kyle Fazzari]

Vendor all dependencies.

Vendor all dependencies.

Unmerged revisions

=== added directory 'internal'
=== added directory 'internal/github.com'
=== added directory 'internal/github.com/blakesmith'
=== added directory 'internal/github.com/blakesmith/ar'
=== added file 'internal/github.com/blakesmith/ar/README.md'
--- internal/github.com/blakesmith/ar/README.md	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,7 @@
+# Golang ar (archive) file reader
+
+This is a simple library for reading and writing [ar](http://en.wikipedia.org/wiki/Ar_(Unix)) files in common format. It is influenced heavily in style and interface from the golang [tar](http://golang.org/pkg/archive/tar/) package.
+
+## Author
+
+Written by Blake Smith <[e-mail]>

=== added file 'internal/github.com/blakesmith/ar/common.go'
--- internal/github.com/blakesmith/ar/common.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/common.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,27 @@
+package ar
+
+import (
+	"time"
+)
+
+const (
+	HEADER_BYTE_SIZE = 60
+	GLOBAL_HEADER    = "!<arch>\n"
+)
+
+type Header struct {
+	Name    string
+	ModTime time.Time
+	Uid     int
+	Gid     int
+	Mode    int64
+	Size    int64
+}
+
+type slicer []byte
+
+func (sp *slicer) next(n int) (b []byte) {
+	s := *sp
+	b, *sp = s[0:n], s[n:]
+	return
+}

=== added file 'internal/github.com/blakesmith/ar/reader.go'
--- internal/github.com/blakesmith/ar/reader.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/reader.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,134 @@
+package ar
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"time"
+)
+
+// Provides read access to an ar archive.
+// Call next to skip files
+//
+// Example:
+//	reader := NewReader(f)
+//	var buf bytes.Buffer
+//	for {
+//		_, err := reader.Next()
+//		if err == io.EOF {
+//			break
+//		}
+//		if err != nil {
+//			t.Errorf(err.Error())
+//		}
+//		io.Copy(&buf, reader)
+//	}
+
+type Reader struct {
+	r   io.Reader
+	nb  int64
+	pad int64
+}
+
+// Copies read data to r. Strips the global ar header.
+func NewReader(r io.Reader) *Reader {
+	io.CopyN(ioutil.Discard, r, 8) // Discard global header
+
+	return &Reader{r: r}
+}
+
+func (rd *Reader) string(b []byte) string {
+	i := len(b) - 1
+	for i > 0 && b[i] == 32 {
+		i--
+	}
+
+	return string(b[0 : i+1])
+}
+
+func (rd *Reader) numeric(b []byte) int64 {
+	i := len(b) - 1
+	for i > 0 && b[i] == 32 {
+		i--
+	}
+
+	n, _ := strconv.ParseInt(string(b[0:i+1]), 10, 64)
+
+	return n
+}
+
+func (rd *Reader) octal(b []byte) int64 {
+	i := len(b) - 1
+	for i > 0 && b[i] == 32 {
+		i--
+	}
+
+	n, _ := strconv.ParseInt(string(b[3:i+1]), 8, 64)
+
+	return n
+}
+
+func (rd *Reader) skipUnread() error {
+	skip := rd.nb + rd.pad
+	rd.nb, rd.pad = 0, 0
+	if seeker, ok := rd.r.(io.Seeker); ok {
+		_, err := seeker.Seek(skip, os.SEEK_CUR)
+		return err
+	}
+
+	_, err := io.CopyN(ioutil.Discard, rd.r, skip)
+	return err
+}
+
+func (rd *Reader) readHeader() (*Header, error) {
+	headerBuf := make([]byte, HEADER_BYTE_SIZE)
+	if _, err := io.ReadFull(rd.r, headerBuf); err != nil {
+		return nil, err
+	}
+
+	header := new(Header)
+	s := slicer(headerBuf)
+
+	header.Name = rd.string(s.next(16))
+	header.ModTime = time.Unix(rd.numeric(s.next(12)), 0)
+	header.Uid = int(rd.numeric(s.next(6)))
+	header.Gid = int(rd.numeric(s.next(6)))
+	header.Mode = rd.octal(s.next(8))
+	header.Size = rd.numeric(s.next(10))
+
+	rd.nb = int64(header.Size)
+	if header.Size%2 == 1 {
+		rd.pad = 1
+	} else {
+		rd.pad = 0
+	}
+
+	return header, nil
+}
+
+// Call Next() to skip to the next file in the archive file.
+// Returns a Header which contains the metadata about the
+// file in the archive.
+func (rd *Reader) Next() (*Header, error) {
+	err := rd.skipUnread()
+	if err != nil {
+		return nil, err
+	}
+
+	return rd.readHeader()
+}
+
+// Read data from the current entry in the archive.
+func (rd *Reader) Read(b []byte) (n int, err error) {
+	if rd.nb == 0 {
+		return 0, io.EOF
+	}
+	if int64(len(b)) > rd.nb {
+		b = b[0:rd.nb]
+	}
+	n, err = rd.r.Read(b)
+	rd.nb -= int64(n)
+
+	return
+}

=== added file 'internal/github.com/blakesmith/ar/reader_test.go'
--- internal/github.com/blakesmith/ar/reader_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/reader_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,92 @@
+package ar
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestReadHeader(t *testing.T) {
+	f, err := os.Open("./fixtures/hello.a")
+	defer f.Close()
+
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+	reader := NewReader(f)
+	header, err := reader.Next()
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+
+	expectedName := "hello.txt"
+	if header.Name != expectedName {
+		t.Errorf("Header name should be %s but is %s", expectedName, header.Name)
+	}
+	expectedModTime := time.Unix(1361157466, 0)
+	if header.ModTime != expectedModTime {
+		t.Errorf("ModTime should be %s but is %s", expectedModTime, header.ModTime)
+	}
+	expectedUid := 501
+	if header.Uid != expectedUid {
+		t.Errorf("Uid should be %s but is %s", expectedUid, header.Uid)
+	}
+	expectedGid := 20
+	if header.Gid != expectedGid {
+		t.Errorf("Gid should be %s but is %s", expectedGid, header.Gid)
+	}
+	expectedMode := int64(0644)
+	if header.Mode != expectedMode {
+		t.Errorf("Mode should be %s but is %s", expectedMode, header.Mode)
+	}
+}
+
+func TestReadBody(t *testing.T) {
+	f, err := os.Open("./fixtures/hello.a")
+	defer f.Close()
+
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+	reader := NewReader(f)
+	_, err = reader.Next()
+	if err != nil && err != io.EOF {
+		t.Errorf(err.Error())
+	}
+	var buf bytes.Buffer
+	io.Copy(&buf, reader)
+
+	expected := []byte("Hello world!\n")
+	actual := buf.Bytes()
+	if !bytes.Equal(actual, expected) {
+		t.Errorf("Data value should be %s but is %s", expected, actual)
+	}
+}
+
+func TestReadMulti(t *testing.T) {
+	f, err := os.Open("./fixtures/multi_archive.a")
+	defer f.Close()
+
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+	reader := NewReader(f)
+	var buf bytes.Buffer
+	for {
+		_, err := reader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Errorf(err.Error())
+		}
+		io.Copy(&buf, reader)
+	}
+	expected := []byte("Hello world!\nI love lamp.\n")
+	actual := buf.Bytes()
+	if !bytes.Equal(expected, actual) {
+		t.Errorf("Concatted byte buffer should be %s but is %s", expected, actual)
+	}
+}

=== added file 'internal/github.com/blakesmith/ar/writer.go'
--- internal/github.com/blakesmith/ar/writer.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/writer.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,103 @@
+package ar
+
+import (
+	"errors"
+	"io"
+	"strconv"
+)
+
+var (
+	ErrWriteTooLong = errors.New("ar: write too long")
+)
+
+// Writer provides sequential writing of an ar archive.
+// An ar archive is sequence of header file pairs
+// Call WriteHeader to begin writing a new file, then call Write to supply the file's data
+//
+// Example:
+// archive := ar.NewWriter(writer)
+// archive.WriteGlobalHeader()
+// header := new(ar.Header)
+// header.Size = 15 // bytes
+// if err := archive.WriteHeader(header); err != nil {
+// 	return err
+// }
+// io.Copy(archive, data)
+type Writer struct {
+	w  io.Writer
+	nb int64 // number of unwritten bytes for the current file entry
+}
+
+// Create a new ar writer that writes to w
+func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
+
+func (aw *Writer) numeric(b []byte, x int64) {
+	s := strconv.FormatInt(x, 10)
+	for len(s) < len(b) {
+		s = s + " "
+	}
+	copy(b, []byte(s))
+}
+
+func (aw *Writer) octal(b []byte, x int64) {
+	s := "100" + strconv.FormatInt(x, 8)
+	for len(s) < len(b) {
+		s = s + " "
+	}
+	copy(b, []byte(s))
+}
+
+func (aw *Writer) string(b []byte, str string) {
+	s := str
+	for len(s) < len(b) {
+		s = s + " "
+	}
+	copy(b, []byte(s))
+}
+
+// Writes to the current entry in the ar archive
+// Returns ErrWriteTooLong if more than header.Size
+// bytes are written after a call to WriteHeader
+func (aw *Writer) Write(b []byte) (n int, err error) {
+	if int64(len(b)) > aw.nb {
+		b = b[0:aw.nb]
+		err = ErrWriteTooLong
+	}
+	n, werr := aw.w.Write(b)
+	aw.nb -= int64(n)
+	if werr != nil {
+		return n, werr
+	}
+
+	if len(b)%2 == 1 { // data size must be aligned to an even byte
+		n2, _ := aw.w.Write([]byte{'\n'})
+		return n + n2, err
+	}
+
+	return
+}
+
+func (aw *Writer) WriteGlobalHeader() error {
+	_, err := aw.w.Write([]byte(GLOBAL_HEADER))
+	return err
+}
+
+// Writes the header to the underlying writer and prepares
+// to receive the file payload
+func (aw *Writer) WriteHeader(hdr *Header) error {
+	aw.nb = int64(hdr.Size)
+	header := make([]byte, HEADER_BYTE_SIZE)
+	s := slicer(header)
+
+	aw.string(s.next(16), hdr.Name)
+	aw.numeric(s.next(12), hdr.ModTime.Unix())
+	aw.numeric(s.next(6), int64(hdr.Uid))
+	aw.numeric(s.next(6), int64(hdr.Gid))
+	aw.octal(s.next(8), hdr.Mode)
+	aw.numeric(s.next(10), hdr.Size)
+	aw.string(s.next(2), "`\n")
+
+	_, err := aw.w.Write(header)
+
+	return err
+}

=== added file 'internal/github.com/blakesmith/ar/writer_test.go'
--- internal/github.com/blakesmith/ar/writer_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/blakesmith/ar/writer_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,71 @@
+package ar
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestGlobalHeaderWrite(t *testing.T) {
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteGlobalHeader(); err != nil {
+		t.Errorf(err.Error())
+	}
+
+	globalHeader := buf.Bytes()
+	expectedHeader := []byte("!<arch>\n")
+	if !bytes.Equal(globalHeader, expectedHeader) {
+		t.Errorf("Global header should be %s but is %s", expectedHeader, globalHeader)
+	}
+}
+
+func TestSimpleFile(t *testing.T) {
+	hdr := new(Header)
+	body := "Hello world!\n"
+	hdr.ModTime = time.Unix(1361157466, 0)
+	hdr.Name = "hello.txt"
+	hdr.Size = int64(len(body))
+	hdr.Mode = 0644
+	hdr.Uid = 501
+	hdr.Gid = 20
+
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	writer.WriteGlobalHeader()
+	writer.WriteHeader(hdr)
+	_, err := writer.Write([]byte(body))
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+
+	f, _ := os.Open("./fixtures/hello.a")
+	defer f.Close()
+
+	b, err := ioutil.ReadAll(f)
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+
+	actual := buf.Bytes()
+	if !bytes.Equal(b, actual) {
+		t.Errorf("Expected %s to equal %s", actual, b)
+	}
+}
+
+func TestWriteTooLong(t *testing.T) {
+	body := "Hello world!\n"
+
+	hdr := new(Header)
+	hdr.Size = 1
+
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	writer.WriteHeader(hdr)
+	_, err := writer.Write([]byte(body))
+	if err != ErrWriteTooLong {
+		t.Errorf("Error should have been: %s", ErrWriteTooLong)
+	}
+}

=== added directory 'internal/github.com/cheggaaa'
=== added directory 'internal/github.com/cheggaaa/pb'
=== added file 'internal/github.com/cheggaaa/pb/LICENSE'
--- internal/github.com/cheggaaa/pb/LICENSE	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/LICENSE	2015-10-30 14:12:15 +0000
@@ -0,0 +1,12 @@
+Copyright (c) 2012, Sergey Cherepanov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file

=== added file 'internal/github.com/cheggaaa/pb/README.md'
--- internal/github.com/cheggaaa/pb/README.md	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,98 @@
+## Terminal progress bar for Go  
+
+Simple progress bar for console programms. 
+    
+
+### Installation
+```
+go get github.com/cheggaaa/pb
+```   
+
+### Usage   
+```Go
+package main
+
+import (
+	"github.com/cheggaaa/pb"
+	"time"
+)
+
+func main() {
+	count := 100000
+	bar := pb.StartNew(count)
+	for i := 0; i < count; i++ {
+		bar.Increment()
+		time.Sleep(time.Millisecond)
+	}
+	bar.FinishPrint("The End!")
+}
+```   
+Result will be like this:
+```
+> go run test.go
+37158 / 100000 [================>_______________________________] 37.16% 1m11s
+```
+
+
+More functions?  
+```Go  
+// create bar
+bar := pb.New(count)
+
+// refresh info every second (default 200ms)
+bar.SetRefreshRate(time.Second)
+
+// show percents (by default already true)
+bar.ShowPercent = true
+
+// show bar (by default already true)
+bar.ShowBar = true
+
+// no need counters
+bar.ShowCounters = false
+
+// show "time left"
+bar.ShowTimeLeft = true
+
+// show average speed    
+bar.ShowSpeed = true
+
+// sets the width of the progress bar
+bar.SetWith(80)
+
+// sets the width of the progress bar, but if terminal size smaller will be ignored
+bar.SetMaxWith(80)
+
+// convert output to readable format (like KB, MB)     
+bar.SetUnits(pb.U_BYTES)
+
+// and start
+bar.Start()
+``` 
+
+Want handle progress of io operations?    
+```Go
+// create and start bar
+bar := pb.New(myDataLen).SetUnits(pb.U_BYTES)
+bar.Start()
+
+// my io.Reader
+r := myReader
+
+// my io.Writer
+w := myWriter
+
+// create multi writer
+writer := io.MultiWriter(w, bar)
+
+// and copy
+io.Copy(writer, r)
+
+// show example/copy/copy.go for advanced example
+
+```
+
+Not like the looks?
+```Go
+bar.Format("<.- >")
+```

=== added file 'internal/github.com/cheggaaa/pb/format.go'
--- internal/github.com/cheggaaa/pb/format.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/format.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,42 @@
+package pb
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const (
+	// By default, without type handle
+	U_NO = 0
+	// Handle as b, Kb, Mb, etc
+	U_BYTES = 1
+)
+
+// Format integer
+func Format(i int64, units int) string {
+	switch units {
+	case U_BYTES:
+		return FormatBytes(i)
+	}
+	// by default just convert to string
+	return strconv.Itoa(int(i))
+}
+
+// Convert bytes to human readable string. Like a 2 MB, 64.2 KB, 52 B
+func FormatBytes(i int64) (result string) {
+	switch {
+	case i > (1024 * 1024 * 1024 * 1024):
+		result = fmt.Sprintf("%#.02f TB", float64(i)/1024/1024/1024/1024)
+	case i > (1024 * 1024 * 1024):
+		result = fmt.Sprintf("%#.02f GB", float64(i)/1024/1024/1024)
+	case i > (1024 * 1024):
+		result = fmt.Sprintf("%#.02f MB", float64(i)/1024/1024)
+	case i > 1024:
+		result = fmt.Sprintf("%#.02f KB", float64(i)/1024)
+	default:
+		result = fmt.Sprintf("%d B", i)
+	}
+	result = strings.Trim(result, " ")
+	return
+}

=== added file 'internal/github.com/cheggaaa/pb/format_test.go'
--- internal/github.com/cheggaaa/pb/format_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/format_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,37 @@
+package pb
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+)
+
+func Test_DefaultsToInteger(t *testing.T) {
+	value := int64(1000)
+	expected := strconv.Itoa(int(value))
+	actual := Format(value, -1)
+
+	if actual != expected {
+		t.Error(fmt.Sprintf("Expected {%s} was {%s}", expected, actual))
+	}
+}
+
+func Test_CanFormatAsInteger(t *testing.T) {
+	value := int64(1000)
+	expected := strconv.Itoa(int(value))
+	actual := Format(value, U_NO)
+
+	if actual != expected {
+		t.Error(fmt.Sprintf("Expected {%s} was {%s}", expected, actual))
+	}
+}
+
+func Test_CanFormatAsBytes(t *testing.T) {
+	value := int64(1000)
+	expected := "1000 B"
+	actual := Format(value, U_BYTES)
+
+	if actual != expected {
+		t.Error(fmt.Sprintf("Expected {%s} was {%s}", expected, actual))
+	}
+}

=== added file 'internal/github.com/cheggaaa/pb/pb.go'
--- internal/github.com/cheggaaa/pb/pb.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,341 @@
+package pb
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+const (
+	// Default refresh rate - 200ms
+	DEFAULT_REFRESH_RATE = time.Millisecond * 200
+	FORMAT               = "[=>-]"
+)
+
+// DEPRECATED
+// variables for backward compatibility, from now do not work
+// use pb.Format and pb.SetRefreshRate
+var (
+	DefaultRefreshRate                         = DEFAULT_REFRESH_RATE
+	BarStart, BarEnd, Empty, Current, CurrentN string
+)
+
+// Create new progress bar object
+func New(total int) (pb *ProgressBar) {
+	return New64(int64(total))
+}
+
+// Create new progress bar object uding int64 as total
+func New64(total int64) (pb *ProgressBar) {
+	pb = &ProgressBar{
+		Total:         total,
+		RefreshRate:   DEFAULT_REFRESH_RATE,
+		ShowPercent:   true,
+		ShowCounters:  true,
+		ShowBar:       true,
+		ShowTimeLeft:  true,
+		ShowFinalTime: true,
+		ManualUpdate:  false,
+		currentValue:  -1,
+	}
+	pb.Format(FORMAT)
+	return
+}
+
+// Create new object and start
+func StartNew(total int) (pb *ProgressBar) {
+	pb = New(total)
+	pb.Start()
+	return
+}
+
+// Callback for custom output
+// For example:
+// bar.Callback = func(s string) {
+//     mySuperPrint(s)
+// }
+//
+type Callback func(out string)
+
+type ProgressBar struct {
+	current int64 // current must be first member of struct (https://code.google.com/p/go/issues/detail?id=5278)
+
+	Total                            int64
+	RefreshRate                      time.Duration
+	ShowPercent, ShowCounters        bool
+	ShowSpeed, ShowTimeLeft, ShowBar bool
+	ShowFinalTime                    bool
+	Output                           io.Writer
+	Callback                         Callback
+	NotPrint                         bool
+	Units                            int
+	Width                            int
+	ForceWidth                       bool
+	ManualUpdate                     bool
+
+	isFinish     bool
+	startTime    time.Time
+	currentValue int64
+
+	prefix, postfix string
+
+	BarStart string
+	BarEnd   string
+	Empty    string
+	Current  string
+	CurrentN string
+}
+
+// Start print
+func (pb *ProgressBar) Start() {
+	pb.startTime = time.Now()
+	if pb.Total == 0 {
+		pb.ShowBar = false
+		pb.ShowTimeLeft = false
+		pb.ShowPercent = false
+	}
+	if !pb.ManualUpdate {
+		go pb.writer()
+	}
+}
+
+// Increment current value
+func (pb *ProgressBar) Increment() int {
+	return pb.Add(1)
+}
+
+// Set current value
+func (pb *ProgressBar) Set(current int) {
+	atomic.StoreInt64(&pb.current, int64(current))
+}
+
+// Add to current value
+func (pb *ProgressBar) Add(add int) int {
+	return int(pb.Add64(int64(add)))
+}
+
+func (pb *ProgressBar) Add64(add int64) int64 {
+	return atomic.AddInt64(&pb.current, add)
+}
+
+// Set prefix string
+func (pb *ProgressBar) Prefix(prefix string) (bar *ProgressBar) {
+	pb.prefix = prefix
+	return pb
+}
+
+// Set postfix string
+func (pb *ProgressBar) Postfix(postfix string) (bar *ProgressBar) {
+	pb.postfix = postfix
+	return pb
+}
+
+// Set custom format for bar
+// Example: bar.Format("[=>_]")
+func (pb *ProgressBar) Format(format string) (bar *ProgressBar) {
+	bar = pb
+	formatEntries := strings.Split(format, "")
+	if len(formatEntries) != 5 {
+		return
+	}
+	pb.BarStart = formatEntries[0]
+	pb.BarEnd = formatEntries[4]
+	pb.Empty = formatEntries[3]
+	pb.Current = formatEntries[1]
+	pb.CurrentN = formatEntries[2]
+	return
+}
+
+// Set bar refresh rate
+func (pb *ProgressBar) SetRefreshRate(rate time.Duration) (bar *ProgressBar) {
+	bar = pb
+	pb.RefreshRate = rate
+	return
+}
+
+// Set units
+// bar.SetUnits(U_NO) - by default
+// bar.SetUnits(U_BYTES) - for Mb, Kb, etc
+func (pb *ProgressBar) SetUnits(units int) (bar *ProgressBar) {
+	bar = pb
+	switch units {
+	case U_NO, U_BYTES:
+		pb.Units = units
+	}
+	return
+}
+
+// Set max width, if width is bigger than terminal width, will be ignored
+func (pb *ProgressBar) SetMaxWidth(width int) (bar *ProgressBar) {
+	bar = pb
+	pb.Width = width
+	pb.ForceWidth = false
+	return
+}
+
+// Set bar width
+func (pb *ProgressBar) SetWidth(width int) (bar *ProgressBar) {
+	bar = pb
+	pb.Width = width
+	pb.ForceWidth = true
+	return
+}
+
+// End print
+func (pb *ProgressBar) Finish() {
+	pb.isFinish = true
+	pb.write(atomic.LoadInt64(&pb.current))
+	if !pb.NotPrint {
+		fmt.Println()
+	}
+}
+
+// End print and write string 'str'
+func (pb *ProgressBar) FinishPrint(str string) {
+	pb.Finish()
+	fmt.Println(str)
+}
+
+// implement io.Writer
+func (pb *ProgressBar) Write(p []byte) (n int, err error) {
+	n = len(p)
+	pb.Add(n)
+	return
+}
+
+// implement io.Reader
+func (pb *ProgressBar) Read(p []byte) (n int, err error) {
+	n = len(p)
+	pb.Add(n)
+	return
+}
+
+// Create new proxy reader over bar
+func (pb *ProgressBar) NewProxyReader(r io.Reader) *Reader {
+	return &Reader{r, pb}
+}
+
+func (pb *ProgressBar) write(current int64) {
+	width := pb.getWidth()
+
+	var percentBox, countersBox, timeLeftBox, speedBox, barBox, end, out string
+
+	// percents
+	if pb.ShowPercent {
+		percent := float64(current) / (float64(pb.Total) / float64(100))
+		percentBox = fmt.Sprintf(" %#.02f %% ", percent)
+	}
+
+	// counters
+	if pb.ShowCounters {
+		if pb.Total > 0 {
+			countersBox = fmt.Sprintf("%s / %s ", Format(current, pb.Units), Format(pb.Total, pb.Units))
+		} else {
+			countersBox = Format(current, pb.Units) + " "
+		}
+	}
+
+	// time left
+	fromStart := time.Now().Sub(pb.startTime)
+	if pb.isFinish {
+		if pb.ShowFinalTime {
+			left := (fromStart / time.Second) * time.Second
+			timeLeftBox = left.String()
+		}
+	} else if pb.ShowTimeLeft && current > 0 {
+		perEntry := fromStart / time.Duration(current)
+		left := time.Duration(pb.Total-current) * perEntry
+		left = (left / time.Second) * time.Second
+		timeLeftBox = left.String()
+	}
+
+	// speed
+	if pb.ShowSpeed && current > 0 {
+		fromStart := time.Now().Sub(pb.startTime)
+		speed := float64(current) / (float64(fromStart) / float64(time.Second))
+		speedBox = Format(int64(speed), pb.Units) + "/s "
+	}
+
+	// bar
+	if pb.ShowBar {
+		size := width - len(countersBox+pb.BarStart+pb.BarEnd+percentBox+timeLeftBox+speedBox+pb.prefix+pb.postfix)
+		if size > 0 {
+			curCount := int(math.Ceil((float64(current) / float64(pb.Total)) * float64(size)))
+			emptCount := size - curCount
+			barBox = pb.BarStart
+			if emptCount < 0 {
+				emptCount = 0
+			}
+			if curCount > size {
+				curCount = size
+			}
+			if emptCount <= 0 {
+				barBox += strings.Repeat(pb.Current, curCount)
+			} else if curCount > 0 {
+				barBox += strings.Repeat(pb.Current, curCount-1) + pb.CurrentN
+			}
+
+			barBox += strings.Repeat(pb.Empty, emptCount) + pb.BarEnd
+		}
+	}
+
+	// check len
+	out = pb.prefix + countersBox + barBox + percentBox + speedBox + timeLeftBox + pb.postfix
+	if len(out) < width {
+		end = strings.Repeat(" ", width-len(out))
+	}
+
+	// and print!
+	switch {
+	case pb.Output != nil:
+		fmt.Fprint(pb.Output, "\r"+out+end)
+	case pb.Callback != nil:
+		pb.Callback(out + end)
+	case !pb.NotPrint:
+		fmt.Print("\r" + out + end)
+	}
+}
+
+func (pb *ProgressBar) getWidth() int {
+	if pb.ForceWidth {
+		return pb.Width
+	}
+
+	width := pb.Width
+	termWidth, _ := terminalWidth()
+	if width == 0 || termWidth <= width {
+		width = termWidth
+	}
+
+	return width
+}
+
+// Write the current state of the progressbar
+func (pb *ProgressBar) Update() {
+	c := atomic.LoadInt64(&pb.current)
+	if c != pb.currentValue {
+		pb.write(c)
+		pb.currentValue = c
+	}
+}
+
+// Internal loop for writing progressbar
+func (pb *ProgressBar) writer() {
+	for {
+		if pb.isFinish {
+			break
+		}
+		pb.Update()
+		time.Sleep(pb.RefreshRate)
+	}
+}
+
+type window struct {
+	Row    uint16
+	Col    uint16
+	Xpixel uint16
+	Ypixel uint16
+}

=== added file 'internal/github.com/cheggaaa/pb/pb_nix.go'
--- internal/github.com/cheggaaa/pb/pb_nix.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb_nix.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,7 @@
+// +build linux darwin freebsd openbsd
+
+package pb
+
+import "syscall"
+
+const sys_ioctl = syscall.SYS_IOCTL

=== added file 'internal/github.com/cheggaaa/pb/pb_solaris.go'
--- internal/github.com/cheggaaa/pb/pb_solaris.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb_solaris.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,5 @@
+// +build solaris
+
+package pb
+
+const sys_ioctl = 54

=== added file 'internal/github.com/cheggaaa/pb/pb_test.go'
--- internal/github.com/cheggaaa/pb/pb_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,30 @@
+package pb
+
+import (
+	"testing"
+)
+
+func Test_IncrementAddsOne(t *testing.T) {
+	count := 5000
+	bar := New(count)
+	expected := 1
+	actual := bar.Increment()
+
+	if actual != expected {
+		t.Errorf("Expected {%d} was {%d}", expected, actual)
+	}
+}
+
+func Test_Width(t *testing.T) {
+	count := 5000
+	bar := New(count)
+	width := 100
+	bar.SetWidth(100).Callback = func(out string) {
+		if len(out) != width {
+			t.Errorf("Bar width expected {%d} was {%d}", len(out), width)
+		}
+	}
+	bar.Start()
+	bar.Increment()
+	bar.Finish()
+}

=== added file 'internal/github.com/cheggaaa/pb/pb_win.go'
--- internal/github.com/cheggaaa/pb/pb_win.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb_win.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,16 @@
+// +build windows
+
+package pb
+
+import (
+	"launchpad.net/crackly/internal/github.com/olekukonko/ts"
+)
+
+func bold(str string) string {
+	return str
+}
+
+func terminalWidth() (int, error) {
+	size, err := ts.GetSize()
+	return size.Col(), err
+}

=== added file 'internal/github.com/cheggaaa/pb/pb_x.go'
--- internal/github.com/cheggaaa/pb/pb_x.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/pb_x.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,46 @@
+// +build linux darwin freebsd openbsd solaris
+
+package pb
+
+import (
+	"os"
+	"runtime"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	TIOCGWINSZ     = 0x5413
+	TIOCGWINSZ_OSX = 1074295912
+)
+
+var tty *os.File
+
+func init() {
+	var err error
+	tty, err = os.Open("/dev/tty")
+	if err != nil {
+		tty = os.Stdin
+	}
+}
+
+func bold(str string) string {
+	return "\033[1m" + str + "\033[0m"
+}
+
+func terminalWidth() (int, error) {
+	w := new(window)
+	tio := syscall.TIOCGWINSZ
+	if runtime.GOOS == "darwin" {
+		tio = TIOCGWINSZ_OSX
+	}
+	res, _, err := syscall.Syscall(sys_ioctl,
+		tty.Fd(),
+		uintptr(tio),
+		uintptr(unsafe.Pointer(w)),
+	)
+	if int(res) == -1 {
+		return 0, err
+	}
+	return int(w.Col), nil
+}

=== added file 'internal/github.com/cheggaaa/pb/reader.go'
--- internal/github.com/cheggaaa/pb/reader.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/cheggaaa/pb/reader.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,17 @@
+package pb
+
+import (
+	"io"
+)
+
+// It's proxy reader, implement io.Reader
+type Reader struct {
+	io.Reader
+	bar *ProgressBar
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	n, err = r.Reader.Read(p)
+	r.bar.Add(n)
+	return
+}

=== added directory 'internal/github.com/gosexy'
=== added directory 'internal/github.com/gosexy/gettext'
=== added file 'internal/github.com/gosexy/gettext/LICENSE'
--- internal/github.com/gosexy/gettext/LICENSE	1970-01-01 00:00:00 +0000
+++ internal/github.com/gosexy/gettext/LICENSE	2015-10-30 14:12:15 +0000
@@ -0,0 +1,20 @@
+Copyright (c) 2012-2013 José Carlos Nieto, http://xiam.menteslibres.org/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

=== added file 'internal/github.com/gosexy/gettext/README.md'
--- internal/github.com/gosexy/gettext/README.md	1970-01-01 00:00:00 +0000
+++ internal/github.com/gosexy/gettext/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,94 @@
+# gosexy/gettext
+
+Go bindings for [GNU gettext][1], an internationalization and localization
+library for writing multilingual systems.
+
+## Requeriments
+
+The GNU C library. If you're using GNU/Linux, FreeBSD or OSX you should already
+have it.
+
+## Installation
+
+Use `go get` to download and install the binding:
+
+```sh
+go get github.com/gosexy/gettext
+```
+
+## Usage
+
+```go
+package main
+
+import (
+	"github.com/gosexy/gettext"
+	"fmt"
+	"os"
+)
+
+func main() {
+	gettext.BindTextdomain("example", ".")
+	gettext.Textdomain("example")
+
+	os.Setenv("LANGUAGE", "es_MX.utf8")
+
+	gettext.SetLocale(gettext.LC_ALL, "")
+
+	fmt.Println(gettext.Gettext("Hello, world!"))
+}
+```
+
+You can use `os.Setenv` to set the `LANGUAGE` environment variable or set it
+on a terminal:
+
+```sh
+export LANGUAGE="es_MX.utf8"
+./gettext-program
+```
+
+Note that `xgettext` does not officially support Go syntax yet, however, you
+can generate a valid `.pot` file by forcing `xgettest` to use the C++
+syntax:
+
+```sh
+xgettext -d example -s gettext_test.go -o example.pot -L c++ -i \
+--keyword=NGettext:1,2 --keyword=Gettext
+```
+
+This will generate a `example.pot` file.
+
+After translating the `.pot` file, you must generate `.po` and `.mo` files and
+remember to set the UTF-8 charset.
+
+```sh
+msginit -l es_MX -o example.po -i example.pot
+msgfmt -c -v -o example.mo example.po
+```
+
+Finally, move the `.mo` file to an appropriate location.
+
+```sh
+mv example.mo examples/es_MX.utf8/LC_MESSAGES/example.mo
+```
+
+## Documentation
+
+You can read `gosexy/gettext` documentation from a terminal
+
+```sh
+go doc github.com/gosexy/gettext
+```
+
+Or you can [browse it](http://godoc.org/github.com/gosexy/gettext) online.
+
+The original gettext documentation could be very useful as well:
+
+```sh
+man 3 gettext
+```
+
+Here's another [good tutorial][2] on using gettext.
+
+[1]: http://www.gnu.org/software/gettext/
+[2]: http://oriya.sarovar.org/docs/gettext_single.html

=== added file 'internal/github.com/gosexy/gettext/gettext.go'
--- internal/github.com/gosexy/gettext/gettext.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/gosexy/gettext/gettext.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,207 @@
+/*
+  Copyright (c) 2012 José Carlos Nieto, http://xiam.menteslibres.org/
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+package gettext
+
+/*
+
+#include <libintl.h>
+#include <locale.h>
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"fmt"
+	"strings"
+	"unsafe"
+)
+
+var (
+	// For all of the locale.
+	LC_ALL = uint(C.LC_ALL)
+
+	// For regular expression matching (it determines the meaning of range
+	// expressions and equivalence classes) and string collation.
+	LC_COLATE = uint(C.LC_ALL)
+
+	// For regular expression matching, character classification, conversion,
+	// case-sensitive comparison, and wide character functions.
+	LC_CTYPE = uint(C.LC_CTYPE)
+
+	// For localizable natural-language messages.
+	LC_MESSAGES = uint(C.LC_MESSAGES)
+
+	// For monetary formatting.
+	LC_MONETARY = uint(C.LC_MONETARY)
+
+	// For number formatting (such as the decimal point and the thousands
+	// separator).
+	LC_NUMERIC = uint(C.LC_NUMERIC)
+
+	// For time and date formatting.
+	LC_TIME = uint(C.LC_TIME)
+)
+
+// Sets or queries the program's current locale.
+func SetLocale(category uint, locale string) string {
+	clocale := C.CString(locale)
+
+	res := C.GoString(C.setlocale(C.int(category), clocale))
+
+	C.free(unsafe.Pointer(clocale))
+	return res
+}
+
+// Sets directory containing message catalogs.
+func BindTextdomain(domainname string, dirname string) string {
+	cdirname := C.CString(dirname)
+	cdomainname := C.CString(domainname)
+
+	res := C.GoString(C.bindtextdomain(cdomainname, cdirname))
+
+	C.free(unsafe.Pointer(cdirname))
+	C.free(unsafe.Pointer(cdomainname))
+	return res
+}
+
+// Sets the output codeset for message catalogs for domain domainname.
+func BindTextdomainCodeset(domainname string, codeset string) string {
+	cdomainname := C.CString(domainname)
+	ccodeset := C.CString(codeset)
+
+	res := C.GoString(C.bind_textdomain_codeset(cdomainname, ccodeset))
+
+	C.free(unsafe.Pointer(cdomainname))
+	C.free(unsafe.Pointer(ccodeset))
+	return res
+}
+
+// Sets or retrieves the current message domain.
+func Textdomain(domainname string) string {
+	cdomainname := C.CString(domainname)
+
+	res := C.GoString(C.textdomain(cdomainname))
+
+	C.free(unsafe.Pointer(cdomainname))
+	return res
+}
+
+// Attempt to translate a text string into the user's native language, by
+// looking up the translation in a message catalog.
+func Gettext(msgid string) string {
+	cmsgid := C.CString(msgid)
+
+	res := C.GoString(C.gettext(cmsgid))
+
+	C.free(unsafe.Pointer(cmsgid))
+	return res
+}
+
+// Like Gettext(), but looking up the message in the specified domain.
+func DGettext(domain string, msgid string) string {
+	cdomain := C.CString(domain)
+	cmsgid := C.CString(msgid)
+
+	res := C.GoString(C.dgettext(cdomain, cmsgid))
+
+	C.free(unsafe.Pointer(cdomain))
+	C.free(unsafe.Pointer(cmsgid))
+	return res
+}
+
+// Like Gettext(), but looking up the message in the specified domain and
+// category.
+func DCGettext(domain string, msgid string, category uint) string {
+	cdomain := C.CString(domain)
+	cmsgid := C.CString(msgid)
+
+	res := C.GoString(C.dcgettext(cdomain, cmsgid, C.int(category)))
+
+	C.free(unsafe.Pointer(cdomain))
+	C.free(unsafe.Pointer(cmsgid))
+	return res
+}
+
+// Attempt to translate a text string into the user's native language, by
+// looking up the appropriate plural form of the translation in a message
+// catalog.
+func NGettext(msgid string, msgid_plural string, n uint64) string {
+	cmsgid := C.CString(msgid)
+	cmsgid_plural := C.CString(msgid_plural)
+
+	res := C.GoString(C.ngettext(cmsgid, cmsgid_plural, C.ulong(n)))
+
+	C.free(unsafe.Pointer(cmsgid))
+	C.free(unsafe.Pointer(cmsgid_plural))
+
+	return res
+}
+
+// Like fmt.Sprintf() but without %!(EXTRA) errors.
+func Sprintf(format string, a ...interface{}) string {
+	expects := strings.Count(format, "%") - strings.Count(format, "%%")
+
+	if expects > 0 {
+		arguments := make([]interface{}, expects)
+		for i := 0; i < expects; i++ {
+			if len(a) > i {
+				arguments[i] = a[i]
+			}
+		}
+		return fmt.Sprintf(format, arguments...)
+	}
+
+	return format
+}
+
+// Like NGettext(), but looking up the message in the specified domain.
+func DNGettext(domainname string, msgid string, msgid_plural string, n uint64) string {
+	cdomainname := C.CString(domainname)
+	cmsgid := C.CString(msgid)
+	cmsgid_plural := C.CString(msgid_plural)
+
+	res := C.GoString(C.dngettext(cdomainname, cmsgid, cmsgid_plural, C.ulong(n)))
+
+	C.free(unsafe.Pointer(cdomainname))
+	C.free(unsafe.Pointer(cmsgid))
+	C.free(unsafe.Pointer(cmsgid_plural))
+
+	return res
+}
+
+// Like NGettext(), but looking up the message in the specified domain and
+// category.
+func DCNGettext(domainname string, msgid string, msgid_plural string, n uint64, category uint) string {
+	cdomainname := C.CString(domainname)
+	cmsgid := C.CString(msgid)
+	cmsgid_plural := C.CString(msgid_plural)
+
+	res := C.GoString(C.dcngettext(cdomainname, cmsgid, cmsgid_plural, C.ulong(n), C.int(category)))
+
+	C.free(unsafe.Pointer(cdomainname))
+	C.free(unsafe.Pointer(cmsgid))
+	C.free(unsafe.Pointer(cmsgid_plural))
+
+	return res
+}

=== added file 'internal/github.com/gosexy/gettext/gettext_test.go'
--- internal/github.com/gosexy/gettext/gettext_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/gosexy/gettext/gettext_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,130 @@
+package gettext
+
+import (
+	"fmt"
+	"os"
+	"testing"
+)
+
+/*
+	NOTE:
+
+	xgettext does not officially support Go syntax, however, you can generate a valid .pot file by forcing
+	xgettest to use the C++ syntax:
+
+	% xgettext -d example -s gettext_test.go -o example.pot -L c++ -i --keyword=NGettext:1,2 --keyword=Gettext
+
+	This will generate a example.pot file.
+
+	After translating the .pot file, you must generate .po and .mo files.
+
+	Remember to set the UTF-8 charset.
+
+	% msginit -l es_MX -o example.po -i example.pot
+	% msgfmt -c -v -o example.mo example.po
+
+	And finally, move the .mo file to an appropriate location.
+
+	% mv example.mo examples/es_MX.utf8/LC_MESSAGES/example.mo
+
+*/
+
+func TestSpanishMexico(t *testing.T) {
+
+	os.Setenv("LANGUAGE", "es_MX.utf8")
+
+	SetLocale(LC_ALL, "")
+	BindTextdomain("example", "./examples/")
+	Textdomain("example")
+
+	t1 := Gettext("Hello, world!")
+
+	fmt.Println(t1)
+
+	if t1 != "¡Hola mundo!" {
+		t.Errorf("Failed translation.")
+	}
+
+	t2 := Sprintf(NGettext("An apple", "%d apples", 1), 1, "garbage")
+
+	fmt.Println(t2)
+
+	if t2 != "Una manzana" {
+		t.Errorf("Failed translation.")
+	}
+
+	t3 := Sprintf(NGettext("An apple", "%d apples", 3), 3)
+
+	fmt.Println(t3)
+
+	if t3 != "3 manzanas" {
+		t.Errorf("Failed translation.")
+	}
+
+	t4 := Gettext("Good morning")
+
+	fmt.Println(t4)
+
+	if t4 != "Buenos días" {
+		t.Errorf("Failed translation.")
+	}
+
+	t5 := Gettext("Good bye!")
+
+	fmt.Println(t5)
+
+	if t5 != "¡Hasta luego!" {
+		t.Errorf("Failed translation.")
+	}
+
+}
+
+func TestGermanDeutschland(t *testing.T) {
+
+	os.Setenv("LANGUAGE", "de_DE.utf8")
+
+	SetLocale(LC_ALL, "")
+	BindTextdomain("example", "./examples/")
+	Textdomain("example")
+
+	t1 := Gettext("Hello, world!")
+
+	fmt.Println(t1)
+
+	if t1 != "Hallo, Welt!" {
+		t.Errorf("Failed translation.")
+	}
+
+	t2 := Sprintf(NGettext("An apple", "%d apples", 1), 1, "garbage")
+
+	fmt.Println(t2)
+
+	if t2 != "Ein Apfel" {
+		t.Errorf("Failed translation.")
+	}
+
+	t3 := Sprintf(NGettext("An apple", "%d apples", 3), 3)
+
+	fmt.Println(t3)
+
+	if t3 != "3 Äpfel" {
+		t.Errorf("Failed translation.")
+	}
+
+	t4 := Gettext("Good morning")
+
+	fmt.Println(t4)
+
+	if t4 != "Guten morgen" {
+		t.Errorf("Failed translation.")
+	}
+
+	t5 := Gettext("Good bye!")
+
+	fmt.Println(t5)
+
+	if t5 != "Aufwiedersehen!" {
+		t.Errorf("Failed translation.")
+	}
+
+}

=== added directory 'internal/github.com/mvo5'
=== added directory 'internal/github.com/mvo5/goconfigparser'
=== added file 'internal/github.com/mvo5/goconfigparser/COPYING'
--- internal/github.com/mvo5/goconfigparser/COPYING	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/goconfigparser/COPYING	2015-10-30 14:12:15 +0000
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Canonical
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

=== added file 'internal/github.com/mvo5/goconfigparser/README.md'
--- internal/github.com/mvo5/goconfigparser/README.md	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/goconfigparser/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,18 @@
+Config File Parser (INI style)
+==============================
+
+This parser is build as a go equivalent of the Python ConfigParser
+module and is aimed for maximum compatibility for both the file format
+and the API. This should make it easy to use existing python style
+configuration files from go and also ease the porting of existing
+python code.
+
+It implements most of RawConfigParser (i.e. no interpolation) at this
+point.
+
+Current Limitations:
+--------------------
+ * no interpolation
+ * no defaults
+ * no write support
+ * not all API is provided
\ No newline at end of file

=== added file 'internal/github.com/mvo5/goconfigparser/configparser.go'
--- internal/github.com/mvo5/goconfigparser/configparser.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/goconfigparser/configparser.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,181 @@
+// A go implementation in the spirit of the python ConfigParser
+package goconfigparser
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// see python3 configparser.py
+var sectionRE = regexp.MustCompile(`\[(?P<header>[^]]+)\]`)
+var optionRE = regexp.MustCompile(`^(?P<option>.*?)\s*(?P<vi>[=|:])\s*(?P<value>.*)$`)
+
+var booleanStates = map[string]bool{
+	"1": true, "yes": true, "true": true, "on": true,
+	"0": false, "no": false, "false": false, "off": false}
+
+type NoOptionError struct {
+	s string
+}
+
+func (e NoOptionError) Error() string {
+	return e.s
+}
+func newNoOptionError(section, option string) *NoOptionError {
+	return &NoOptionError{s: fmt.Sprintf("No option %s in section %s", option, section)}
+}
+
+type NoSectionError struct {
+	s string
+}
+
+func (e NoSectionError) Error() string {
+	return e.s
+}
+func newNoSectionError(section string) *NoSectionError {
+	return &NoSectionError{s: fmt.Sprintf("No section: %s", section)}
+}
+
+type ConfigParser struct {
+	sections map[string]Section
+
+	// allow data with no ["section"] header via Get("", key)
+	AllowNoSectionHeader bool
+}
+
+type Section struct {
+	options map[string]string
+}
+
+// Create a new empty ConfigParser
+func New() (cfg *ConfigParser) {
+	return &ConfigParser{
+		sections: make(map[string]Section)}
+}
+
+// Return a string slice of the sections available
+func (c *ConfigParser) Sections() (res []string) {
+	for k, _ := range c.sections {
+		res = append(res, k)
+	}
+	return res
+}
+
+// Return a string slice of the options available in the given section
+func (c *ConfigParser) Options(section string) (res []string, err error) {
+	sect, ok := c.sections[section]
+	if !ok {
+		return res, newNoSectionError(section)
+	}
+	for k, _ := range sect.options {
+		res = append(res, k)
+	}
+	return res, err
+}
+
+// Attempt to parse the given string as a configuration
+// It may return a error if the parsing fails
+func (c *ConfigParser) ReadString(s string) (err error) {
+	r := strings.NewReader(s)
+	return c.Read(r)
+}
+
+// Attempt to parse the given file as a configuration
+// It may return a error if the parsing fails
+func (c *ConfigParser) ReadFile(path string) (err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	return c.Read(f)
+}
+
+// Attempt to parse the given io.Reader as a configuration
+// It may return a error if the reading fails
+func (c *ConfigParser) Read(r io.Reader) (err error) {
+	scanner := bufio.NewScanner(r)
+
+	curSect := ""
+	// we allow files with no [section] header in this mode, by
+	// default its a error to be alinged with what python configparser
+	// is doing
+	if c.AllowNoSectionHeader {
+		c.sections[""] = Section{
+			options: make(map[string]string)}
+	}
+	for scanner.Scan() {
+		line := scanner.Text()
+		if sectionRE.MatchString(line) {
+			matches := sectionRE.FindStringSubmatch(line)
+			curSect = matches[1]
+			c.sections[curSect] = Section{
+				options: make(map[string]string)}
+		} else if optionRE.MatchString(line) {
+			matches := optionRE.FindStringSubmatch(line)
+			key := matches[1]
+			value := matches[3]
+			if _, ok := c.sections[curSect]; !ok {
+				return newNoSectionError(curSect)
+			}
+			c.sections[curSect].options[key] = value
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		log.Printf("ConfigParser scan error %s from %s", err, r)
+	}
+	return err
+}
+
+// Return the option for the given section as string or an error
+func (c *ConfigParser) Get(section, option string) (val string, err error) {
+	if _, ok := c.sections[section]; !ok {
+		return val, newNoSectionError(section)
+	}
+	sec := c.sections[section]
+
+	if _, ok := sec.options[option]; !ok {
+		return val, newNoOptionError(section, option)
+	}
+
+	return sec.options[option], err
+}
+
+// Return the option for the given section as integer or an error
+func (c *ConfigParser) Getint(section, option string) (val int, err error) {
+	sv, err := c.Get(section, option)
+	if err != nil {
+		return val, err
+	}
+	return strconv.Atoi(sv)
+}
+
+// Return the option for the given section as float or an error
+func (c *ConfigParser) Getfloat(section, option string) (val float64, err error) {
+	sv, err := c.Get(section, option)
+	if err != nil {
+		return val, err
+	}
+	return strconv.ParseFloat(sv, 64)
+}
+
+// Return the option for the given section as boolean or an error
+func (c *ConfigParser) Getbool(section, option string) (val bool, err error) {
+	sv, err := c.Get(section, option)
+	if err != nil {
+		return val, err
+	}
+
+	val, ok := booleanStates[strings.ToLower(sv)]
+	if !ok {
+		return val, errors.New(fmt.Sprintf("No boolean: %s", sv))
+	}
+
+	return val, err
+}

=== added file 'internal/github.com/mvo5/goconfigparser/configparser_test.go'
--- internal/github.com/mvo5/goconfigparser/configparser_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/goconfigparser/configparser_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,127 @@
+package goconfigparser
+
+import (
+	"io/ioutil"
+	"sort"
+	"strings"
+	"testing"
+
+	. "launchpad.net/crackly/internal/launchpad.net/gocheck"
+)
+
+// Hook up gocheck into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+// partition specific testsuite
+type ConfigParserTestSuite struct {
+	cfg *ConfigParser
+}
+
+var _ = Suite(&ConfigParserTestSuite{})
+
+const SAMPLE_INI = `
+[service]
+base: system-image.ubuntu.com
+http_port: 80
+https_port: 443
+channel: ubuntu-core/devel-proposed
+device: generic_amd64
+build_number: 246
+version_detail: ubuntu=20150121,raw-device=20150121,version=246
+
+[foo]
+bar: baz
+yesbool: On
+nobool: off
+float: 3.14
+
+[testOptions]
+One: 1
+Two: 2
+`
+
+func (s *ConfigParserTestSuite) SetUpTest(c *C) {
+	s.cfg = New()
+	c.Assert(s.cfg, NotNil)
+	err := s.cfg.ReadString(SAMPLE_INI)
+	c.Assert(err, IsNil)
+}
+
+func (s *ConfigParserTestSuite) TestSection(c *C) {
+	sections := s.cfg.Sections()
+	sort.Strings(sections)
+	c.Assert(sections, DeepEquals, []string{"foo", "service", "testOptions"})
+}
+
+func (s *ConfigParserTestSuite) TestOptions(c *C) {
+	options, err := s.cfg.Options("testOptions")
+	c.Assert(err, IsNil)
+	sort.Strings(options)
+	c.Assert(options, DeepEquals, []string{"One", "Two"})
+}
+
+func (s *ConfigParserTestSuite) TestGet(c *C) {
+	val, err := s.cfg.Get("service", "base")
+	c.Assert(err, IsNil)
+	c.Assert(val, Equals, "system-image.ubuntu.com")
+}
+
+func (s *ConfigParserTestSuite) TestGetint(c *C) {
+	intval, err := s.cfg.Getint("service", "http_port")
+	c.Assert(err, IsNil)
+	c.Assert(intval, Equals, 80)
+}
+
+func (s *ConfigParserTestSuite) TestGetfloat(c *C) {
+	intval, err := s.cfg.Getfloat("foo", "float")
+	c.Assert(err, IsNil)
+	c.Assert(intval, Equals, 3.14)
+}
+
+func (s *ConfigParserTestSuite) TestGetbool(c *C) {
+	boolval, err := s.cfg.Getbool("foo", "yesbool")
+	c.Assert(err, IsNil)
+	c.Assert(boolval, Equals, true)
+
+	boolval, err = s.cfg.Getbool("foo", "nobool")
+	c.Assert(err, IsNil)
+	c.Assert(boolval, Equals, false)
+
+	boolval, err = s.cfg.Getbool("foo", "bar")
+	c.Assert(err.Error(), Equals, "No boolean: baz")
+}
+
+func (s *ConfigParserTestSuite) TestErrors(c *C) {
+	val, err := s.cfg.Get("foo", "bar")
+	c.Assert(err, IsNil)
+	c.Assert(val, Equals, "baz")
+
+	val, err = s.cfg.Get("foo", "no-such-option")
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "No option no-such-option in section foo")
+
+	val, err = s.cfg.Get("no-such-section", "no-such-value")
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "No section: no-such-section")
+}
+
+func (s *ConfigParserTestSuite) TestAllowNoSection(c *C) {
+	s.cfg = New()
+	s.cfg.AllowNoSectionHeader = true
+	err := s.cfg.Read(strings.NewReader(`foo=bar`))
+	c.Assert(err, IsNil)
+	val, err := s.cfg.Get("", "foo")
+	c.Assert(val, Equals, "bar")
+}
+
+func (s *ConfigParserTestSuite) TestReadFile(c *C) {
+	tmp, err := ioutil.TempFile("", "")
+	c.Assert(err, IsNil)
+	tmp.Write([]byte(SAMPLE_INI))
+
+	s.cfg = New()
+	err = s.cfg.ReadFile(tmp.Name())
+	c.Assert(err, IsNil)
+	val, err := s.cfg.Get("foo", "bar")
+	c.Assert(val, Equals, "baz")
+}

=== added directory 'internal/github.com/mvo5/uboot-go'
=== added directory 'internal/github.com/mvo5/uboot-go/uenv'
=== added file 'internal/github.com/mvo5/uboot-go/uenv/env.go'
--- internal/github.com/mvo5/uboot-go/uenv/env.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/uboot-go/uenv/env.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,235 @@
+package uenv
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"io/ioutil"
+	"os"
+	"sort"
+	"strings"
+)
+
+// FIXME: add config option for that so that the user can select if
+//        he/she wants env with or without flags
+var headerSize = 5
+
+// Env contains the data of the uboot environment
+type Env struct {
+	fname string
+	size  int
+	data  map[string]string
+}
+
+// little endian helpers
+func readUint32(data []byte) uint32 {
+	var ret uint32
+	buf := bytes.NewBuffer(data)
+	binary.Read(buf, binary.LittleEndian, &ret)
+	return ret
+}
+
+func writeUint32(u uint32) []byte {
+	buf := bytes.NewBuffer(nil)
+	binary.Write(buf, binary.LittleEndian, &u)
+	return buf.Bytes()
+}
+
+// Create a new empty uboot env file with the given size
+func Create(fname string, size int) (*Env, error) {
+	f, err := os.Create(fname)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	env := &Env{
+		fname: fname,
+		size:  size,
+		data:  make(map[string]string),
+	}
+
+	return env, nil
+}
+
+// Open opens a existing uboot env file
+func Open(fname string) (*Env, error) {
+	f, err := os.Open(fname)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	contentWithHeader, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, err
+	}
+	crc := readUint32(contentWithHeader)
+
+	payload := contentWithHeader[headerSize:]
+	actualCRC := crc32.ChecksumIEEE(payload)
+	if crc != actualCRC {
+		return nil, fmt.Errorf("bad CRC: %v != %v", crc, actualCRC)
+	}
+	eof := bytes.Index(payload, []byte{0, 0})
+
+	env := &Env{
+		fname: fname,
+		size:  len(contentWithHeader),
+		data:  parseData(payload[:eof]),
+	}
+
+	return env, nil
+}
+
+func parseData(data []byte) map[string]string {
+	out := make(map[string]string)
+
+	for _, envStr := range bytes.Split(data, []byte{0}) {
+		if len(envStr) == 0 || envStr[0] == 0 || envStr[0] == 255 {
+			continue
+		}
+		l := strings.SplitN(string(envStr), "=", 2)
+		if len(l) == 1 {
+			panic(fmt.Sprintf("invalid line %q (corrupted file?)", envStr))
+		}
+		key := l[0]
+		value := l[1]
+		out[key] = value
+	}
+
+	return out
+}
+
+func (env *Env) String() string {
+	out := ""
+
+	env.iterEnv(func(key, value string) {
+		out += fmt.Sprintf("%s=%s\n", key, value)
+	})
+
+	return out
+}
+
+// Get the value of the environment variable
+func (env *Env) Get(name string) string {
+	return env.data[name]
+}
+
+// Set an environment name to the given value, if the value is empty
+// the variable will be removed from the environment
+func (env *Env) Set(name, value string) {
+	if name == "" {
+		panic(fmt.Sprintf("Set() can not be called with empty key for value: %q", value))
+	}
+	if value == "" {
+		delete(env.data, name)
+		return
+	}
+	env.data[name] = value
+}
+
+// iterEnv calls the passed function f with key, value for environment
+// vars. The order is guaranteed (unlike just iterating over the map)
+func (env *Env) iterEnv(f func(key, value string)) {
+	keys := make([]string, 0, len(env.data))
+	for k := range env.data {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		if k == "" {
+			panic("iterEnv iterating over a empty key")
+		}
+
+		f(k, env.data[k])
+	}
+}
+
+// Save will write out the environment data
+func (env *Env) Save() error {
+	w := bytes.NewBuffer(nil)
+	// will panic if the buffer can't grow, all writes to
+	// the buffer will be ok because we sized it correctly
+	w.Grow(env.size - headerSize)
+
+	// write the payload
+	env.iterEnv(func(key, value string) {
+		w.Write([]byte(fmt.Sprintf("%s=%s", key, value)))
+		w.Write([]byte{0})
+	})
+
+	// write double \0 to mark the end of the env
+	w.Write([]byte{0})
+
+	// no keys, so no previous \0 was written so we write one here
+	if len(env.data) == 0 {
+		w.Write([]byte{0})
+	}
+
+	// write ff into the remaining parts
+	writtenSoFar := w.Len()
+	for i := 0; i < env.size-headerSize-writtenSoFar; i++ {
+		w.Write([]byte{0xff})
+	}
+
+	// checksum
+	crc := crc32.ChecksumIEEE(w.Bytes())
+
+	// Note that we overwrite the existing file and do not do
+	// the usual write-rename. The rationale is that we want to
+	// minimize the amount of writes happening on a potential
+	// FAT partition where the env is loaded from. The file will
+	// always be of a fixed size so we know the writes will not
+	// fail because of ENOSPC.
+	//
+	// The size of the env file never changes so we do not
+	// truncate it.
+	//
+	// We also do not O_TRUNC to avoid reallocations on the FS
+	// to minimize risk of fs corruption.
+	f, err := os.OpenFile(env.fname, os.O_WRONLY, 0666)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if _, err := f.Write(writeUint32(crc)); err != nil {
+		return err
+	}
+	// padding bytes (e.g. for redundant header)
+	pad := make([]byte, headerSize-binary.Size(crc))
+	if _, err := f.Write(pad); err != nil {
+		return err
+	}
+	if _, err := f.Write(w.Bytes()); err != nil {
+		return err
+	}
+
+	return f.Sync()
+}
+
+// Import is a helper that imports a given text file that contains
+// "key=value" paris into the uboot env. Lines starting with ^# are
+// ignored (like the input file on mkenvimage)
+func (env *Env) Import(r io.Reader) error {
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "#") || len(line) == 0 {
+			continue
+		}
+		l := strings.SplitN(line, "=", 2)
+		if len(l) == 1 {
+			return fmt.Errorf("Invalid line: %q", line)
+		}
+		env.data[l[0]] = l[1]
+
+	}
+
+	return scanner.Err()
+}

=== added file 'internal/github.com/mvo5/uboot-go/uenv/env_test.go'
--- internal/github.com/mvo5/uboot-go/uenv/env_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/mvo5/uboot-go/uenv/env_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,203 @@
+package uenv
+
+import (
+	"bytes"
+	"hash/crc32"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	. "launchpad.net/crackly/internal/gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+type uenvTestSuite struct {
+	envFile string
+}
+
+var _ = Suite(&uenvTestSuite{})
+
+func (u *uenvTestSuite) SetUpTest(c *C) {
+	u.envFile = filepath.Join(c.MkDir(), "uboot.env")
+}
+
+func (u *uenvTestSuite) TestSetNoDuplicate(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+	env.Set("foo", "bar")
+	env.Set("foo", "bar")
+	c.Assert(env.String(), Equals, "foo=bar\n")
+}
+
+func (u *uenvTestSuite) TestOpenEnv(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+	env.Set("foo", "bar")
+	c.Assert(env.String(), Equals, "foo=bar\n")
+	err = env.Save()
+	c.Assert(err, IsNil)
+
+	env2, err := Open(u.envFile)
+	c.Assert(err, IsNil)
+	c.Assert(env2.String(), Equals, "foo=bar\n")
+}
+
+func (u *uenvTestSuite) TestGetSimple(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+	env.Set("foo", "bar")
+	c.Assert(env.Get("foo"), Equals, "bar")
+}
+
+func (u *uenvTestSuite) TestGetNoSuchEntry(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+	c.Assert(env.Get("no-such-entry"), Equals, "")
+}
+
+func (u *uenvTestSuite) TestImport(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+
+	r := strings.NewReader("foo=bar\n#comment\n\nbaz=baz")
+	err = env.Import(r)
+	c.Assert(err, IsNil)
+	// order is alphabetic
+	c.Assert(env.String(), Equals, "baz=baz\nfoo=bar\n")
+}
+
+func (u *uenvTestSuite) TestImportHasError(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+
+	r := strings.NewReader("foxy")
+	err = env.Import(r)
+	c.Assert(err, ErrorMatches, "Invalid line: \"foxy\"")
+}
+
+func (u *uenvTestSuite) TestSetEmptyUnsets(c *C) {
+	env, err := Create(u.envFile, 4096)
+	c.Assert(err, IsNil)
+
+	env.Set("foo", "bar")
+	c.Assert(env.String(), Equals, "foo=bar\n")
+	env.Set("foo", "")
+	c.Assert(env.String(), Equals, "")
+}
+
+func (u *uenvTestSuite) makeUbootEnvFromData(c *C, mockData []byte) {
+	w := bytes.NewBuffer(nil)
+	crc := crc32.ChecksumIEEE(mockData)
+	w.Write(writeUint32(crc))
+	w.Write([]byte{0})
+	w.Write(mockData)
+
+	f, err := os.Create(u.envFile)
+	c.Assert(err, IsNil)
+	defer f.Close()
+	_, err = f.Write(w.Bytes())
+	c.Assert(err, IsNil)
+}
+
+// ensure that the data after \0\0 is discarded (except for crc)
+func (u *uenvTestSuite) TestReadStopsAfterDoubleNull(c *C) {
+	mockData := []byte{
+		// foo=bar
+		0x66, 0x6f, 0x6f, 0x3d, 0x62, 0x61, 0x72,
+		// eof
+		0x00, 0x00,
+		// junk after eof as written by fw_setenv sometimes
+		// =b
+		0x3d, 62,
+		// empty
+		0xff, 0xff,
+	}
+	u.makeUbootEnvFromData(c, mockData)
+
+	env, err := Open(u.envFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "foo=bar\n")
+}
+
+func (u *uenvTestSuite) TestReadEmptyFile(c *C) {
+	mockData := []byte{
+		// eof
+		0x00, 0x00,
+		// empty
+		0xff, 0xff,
+	}
+	u.makeUbootEnvFromData(c, mockData)
+
+	env, err := Open(u.envFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "")
+}
+
+func (u *uenvTestSuite) TestWritesEmptyFileWithDoubleNewline(c *C) {
+	env, err := Create(u.envFile, 12)
+	c.Assert(err, IsNil)
+	err = env.Save()
+	c.Assert(err, IsNil)
+
+	r, err := os.Open(u.envFile)
+	c.Assert(err, IsNil)
+	defer r.Close()
+	content, err := ioutil.ReadAll(r)
+	c.Assert(err, IsNil)
+	c.Assert(content, DeepEquals, []byte{
+		// crc
+		0x11, 0x38, 0xb3, 0x89,
+		// redundant
+		0x0,
+		// eof
+		0x0, 0x0,
+		// footer
+		0xff, 0xff, 0xff, 0xff, 0xff,
+	})
+
+	env, err = Open(u.envFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "")
+}
+
+func (u *uenvTestSuite) TestWritesContentCorrectly(c *C) {
+	totalSize := 16
+
+	env, err := Create(u.envFile, totalSize)
+	c.Assert(err, IsNil)
+	env.Set("a", "b")
+	env.Set("c", "d")
+	err = env.Save()
+	c.Assert(err, IsNil)
+
+	r, err := os.Open(u.envFile)
+	c.Assert(err, IsNil)
+	defer r.Close()
+	content, err := ioutil.ReadAll(r)
+	c.Assert(err, IsNil)
+	c.Assert(content, DeepEquals, []byte{
+		// crc
+		0xc7, 0xd9, 0x6b, 0xc5,
+		// redundant
+		0x0,
+		// a=b
+		0x61, 0x3d, 0x62,
+		// eol
+		0x0,
+		// c=d
+		0x63, 0x3d, 0x64,
+		// eof
+		0x0, 0x0,
+		// footer
+		0xff, 0xff,
+	})
+
+	env, err = Open(u.envFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "a=b\nc=d\n")
+	c.Assert(env.size, Equals, totalSize)
+}

=== added directory 'internal/github.com/olekukonko'
=== added directory 'internal/github.com/olekukonko/ts'
=== added file 'internal/github.com/olekukonko/ts/LICENCE'
--- internal/github.com/olekukonko/ts/LICENCE	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/LICENCE	2015-10-30 14:12:15 +0000
@@ -0,0 +1,19 @@
+Copyright (C) 2014 by Oleku Konko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file

=== added file 'internal/github.com/olekukonko/ts/README.md'
--- internal/github.com/olekukonko/ts/README.md	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,28 @@
+ts (Terminal Size)
+==
+
+[![Build Status](https://travis-ci.org/olekukonko/ts.png?branch=master)](https://travis-ci.org/olekukonko/ts) [![Total views](https://sourcegraph.com/api/repos/github.com/olekukonko/ts/counters/views.png)](https://sourcegraph.com/github.com/olekukonko/ts)
+
+Simple go Application to get Terminal Size. So Many Implementations do not support windows but `ts` has full windows support.
+Run `go get github.com/olekukonko/ts` to download and install
+
+#### Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/olekukonko/ts"
+)
+
+func main() {
+	size, _ := ts.GetSize()
+	fmt.Println(size.Col())  // Get Width
+	fmt.Println(size.Row())  // Get Height
+	fmt.Println(size.PosX()) // Get X position
+	fmt.Println(size.PosY()) // Get Y position
+}
+```
+
+[See Documentation](http://godoc.org/github.com/olekukonko/ts)

=== added file 'internal/github.com/olekukonko/ts/doc.go'
--- internal/github.com/olekukonko/ts/doc.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/doc.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,36 @@
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+/**
+
+Simple go Application to get Terminal Size. So Many Implementations do not support windows but `ts` has full windows support.
+Run `go get github.com/olekukonko/ts` to download and install
+
+Installation
+
+Minimum requirements are Go 1.1+ with fill Windows support
+
+Example
+
+	package main
+
+	import (
+		"fmt"
+		"github.com/olekukonko/ts"
+	)
+
+	func main() {
+		size, _ := ts.GetSize()
+		fmt.Println(size.Col())  // Get Width
+		fmt.Println(size.Row())  // Get Height
+		fmt.Println(size.PosX()) // Get X position
+		fmt.Println(size.PosY()) // Get Y position
+	}
+
+**/
+
+package ts

=== added file 'internal/github.com/olekukonko/ts/ts.go'
--- internal/github.com/olekukonko/ts/ts.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,36 @@
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+// Return System Size
+type Size struct {
+	row  uint16
+	col  uint16
+	posX uint16
+	posY uint16
+}
+
+// Get Terminal Width
+func (w Size) Col() int {
+	return int(w.col)
+}
+
+// Get Terminal Height
+func (w Size) Row() int {
+	return int(w.row)
+}
+
+// Get Position X
+func (w Size) PosX() int {
+	return int(w.posX)
+}
+
+// Get Position Y
+func (w Size) PosY() int {
+	return int(w.posY)
+}

=== added file 'internal/github.com/olekukonko/ts/ts_darwin.go'
--- internal/github.com/olekukonko/ts/ts_darwin.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_darwin.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,14 @@
+// +build darwin
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+const (
+	TIOCGWINSZ = 0x40087468
+)

=== added file 'internal/github.com/olekukonko/ts/ts_linux.go'
--- internal/github.com/olekukonko/ts/ts_linux.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_linux.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,13 @@
+// +build linux
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+package ts
+
+const (
+	TIOCGWINSZ = 0x5413
+)

=== added file 'internal/github.com/olekukonko/ts/ts_other.go'
--- internal/github.com/olekukonko/ts/ts_other.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_other.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,14 @@
+// +build !windows,!darwin,!freebsd,!netbsd,!openbsd,!linux
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+const (
+	TIOCGWINSZ = 0
+)

=== added file 'internal/github.com/olekukonko/ts/ts_test.go'
--- internal/github.com/olekukonko/ts/ts_test.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,32 @@
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+import (
+	"fmt"
+	"testing"
+)
+
+func ExampleGetSize() {
+	size, _ := GetSize()
+	fmt.Println(size.Col())  // Get Width
+	fmt.Println(size.Row())  // Get Height
+	fmt.Println(size.PosX()) // Get X position
+	fmt.Println(size.PosY()) // Get Y position
+}
+
+func TestSize(t *testing.T) {
+	size, err := GetSize()
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if size.Col() == 0 || size.Row() == 0 {
+		t.Fatalf("Screen Size Failed")
+	}
+}

=== added file 'internal/github.com/olekukonko/ts/ts_unix.go'
--- internal/github.com/olekukonko/ts/ts_unix.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_unix.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,14 @@
+// +build  freebsd netbsd openbsd
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+const (
+	TIOCGWINSZ = 0x40087468
+)

=== added file 'internal/github.com/olekukonko/ts/ts_windows.go'
--- internal/github.com/olekukonko/ts/ts_windows.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_windows.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,64 @@
+// +build windows
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal  API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+	// Retrieves information about the specified console screen buffer.
+	// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx
+	screenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+)
+
+//   Contains information about a console screen buffer.
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093(v=vs.85).aspx
+type CONSOLE_SCREEN_BUFFER_INFO struct {
+	DwSize              COORD
+	DwCursorPosition    COORD
+	WAttributes         uint16
+	SrWindow            SMALL_RECT
+	DwMaximumWindowSize COORD
+}
+
+// Defines the coordinates of a character cell in a console screen buffer.
+// The origin of the coordinate system (0,0) is at the top, left cell of the buffer.
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119(v=vs.85).aspx
+type COORD struct {
+	X, Y uint16
+}
+
+// Defines the coordinates of the upper left and lower right corners of a rectangle.
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311(v=vs.85).aspx
+type SMALL_RECT struct {
+	Left, Top, Right, Bottom uint16
+}
+
+func GetSize() (ws Size, err error) {
+	var info CONSOLE_SCREEN_BUFFER_INFO
+	rc, _, err := screenBufferInfo.Call(
+		uintptr(syscall.Stdout),
+		uintptr(unsafe.Pointer(&info)))
+
+	if rc == 0 {
+		return ws, err
+	}
+
+	ws = Size{info.SrWindow.Bottom,
+		info.SrWindow.Right,
+		info.DwCursorPosition.X,
+		info.DwCursorPosition.Y}
+
+	return ws, nil
+}

=== added file 'internal/github.com/olekukonko/ts/ts_x.go'
--- internal/github.com/olekukonko/ts/ts_x.go	1970-01-01 00:00:00 +0000
+++ internal/github.com/olekukonko/ts/ts_x.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,46 @@
+// +build !windows
+
+// Copyright 2014 Oleku Konko All rights reserved.
+// Use of this source code is governed by a MIT
+// license that can be found in the LICENSE file.
+
+// This module is a Terminal API for the Go Programming Language.
+// The protocols were written in pure Go and works on windows and unix systems
+
+package ts
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+// Get Windows Size
+func GetSize() (ws Size, err error) {
+	_, _, ec := syscall.Syscall(syscall.SYS_IOCTL,
+		uintptr(syscall.Stdout),
+		uintptr(TIOCGWINSZ),
+		uintptr(unsafe.Pointer(&ws)))
+
+	err = getError(ec)
+
+	if TIOCGWINSZ == 0 && err != nil {
+		ws = Size{80, 25, 0, 0}
+	}
+	return ws, err
+}
+
+func getError(ec interface{}) (err error) {
+	switch v := ec.(type) {
+
+	case syscall.Errno: // Some implementation return syscall.Errno number
+		if v != 0 {
+			err = syscall.Errno(v)
+		}
+
+	case error: // Some implementation return error
+		err = ec.(error)
+	default:
+		err = nil
+	}
+	return
+}

=== added directory 'internal/gopkg.in'
=== added directory 'internal/gopkg.in/check.v1'
=== added file 'internal/gopkg.in/check.v1/LICENSE'
--- internal/gopkg.in/check.v1/LICENSE	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/LICENSE	2015-10-30 14:12:15 +0000
@@ -0,0 +1,25 @@
+Gocheck - A rich testing framework for Go
+ 
+Copyright (c) 2010-2013 Gustavo Niemeyer <[e-mail]>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== added file 'internal/gopkg.in/check.v1/README.md'
--- internal/gopkg.in/check.v1/README.md	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/README.md	2015-10-30 14:12:15 +0000
@@ -0,0 +1,20 @@
+Instructions
+============
+
+Install the package with:
+
+    go get gopkg.in/check.v1
+    
+Import it with:
+
+    import "gopkg.in/check.v1"
+
+and use _check_ as the package name inside the code.
+
+For more details, visit the project page:
+
+* http://labix.org/gocheck
+
+and the API documentation:
+
+* https://gopkg.in/check.v1

=== added file 'internal/gopkg.in/check.v1/TODO'
--- internal/gopkg.in/check.v1/TODO	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/TODO	2015-10-30 14:12:15 +0000
@@ -0,0 +1,2 @@
+- Assert(slice, Contains, item)
+- Parallel test support

=== added file 'internal/gopkg.in/check.v1/benchmark.go'
--- internal/gopkg.in/check.v1/benchmark.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/benchmark.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,163 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package check
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+var memStats runtime.MemStats
+
+// testingB is a type passed to Benchmark functions to manage benchmark
+// timing and to specify the number of iterations to run.
+type timer struct {
+	start     time.Time // Time test or benchmark started
+	duration  time.Duration
+	N         int
+	bytes     int64
+	timerOn   bool
+	benchTime time.Duration
+	// The initial states of memStats.Mallocs and memStats.TotalAlloc.
+	startAllocs uint64
+	startBytes  uint64
+	// The net total of this test after being run.
+	netAllocs uint64
+	netBytes  uint64
+}
+
+// StartTimer starts timing a test. This function is called automatically
+// before a benchmark starts, but it can also used to resume timing after
+// a call to StopTimer.
+func (c *C) StartTimer() {
+	if !c.timerOn {
+		c.start = time.Now()
+		c.timerOn = true
+
+		runtime.ReadMemStats(&memStats)
+		c.startAllocs = memStats.Mallocs
+		c.startBytes = memStats.TotalAlloc
+	}
+}
+
+// StopTimer stops timing a test. This can be used to pause the timer
+// while performing complex initialization that you don't
+// want to measure.
+func (c *C) StopTimer() {
+	if c.timerOn {
+		c.duration += time.Now().Sub(c.start)
+		c.timerOn = false
+		runtime.ReadMemStats(&memStats)
+		c.netAllocs += memStats.Mallocs - c.startAllocs
+		c.netBytes += memStats.TotalAlloc - c.startBytes
+	}
+}
+
+// ResetTimer sets the elapsed benchmark time to zero.
+// It does not affect whether the timer is running.
+func (c *C) ResetTimer() {
+	if c.timerOn {
+		c.start = time.Now()
+		runtime.ReadMemStats(&memStats)
+		c.startAllocs = memStats.Mallocs
+		c.startBytes = memStats.TotalAlloc
+	}
+	c.duration = 0
+	c.netAllocs = 0
+	c.netBytes = 0
+}
+
+// SetBytes informs the number of bytes that the benchmark processes
+// on each iteration. If this is called in a benchmark it will also
+// report MB/s.
+func (c *C) SetBytes(n int64) {
+	c.bytes = n
+}
+
+func (c *C) nsPerOp() int64 {
+	if c.N <= 0 {
+		return 0
+	}
+	return c.duration.Nanoseconds() / int64(c.N)
+}
+
+func (c *C) mbPerSec() float64 {
+	if c.bytes <= 0 || c.duration <= 0 || c.N <= 0 {
+		return 0
+	}
+	return (float64(c.bytes) * float64(c.N) / 1e6) / c.duration.Seconds()
+}
+
+func (c *C) timerString() string {
+	if c.N <= 0 {
+		return fmt.Sprintf("%3.3fs", float64(c.duration.Nanoseconds())/1e9)
+	}
+	mbs := c.mbPerSec()
+	mb := ""
+	if mbs != 0 {
+		mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
+	}
+	nsop := c.nsPerOp()
+	ns := fmt.Sprintf("%10d ns/op", nsop)
+	if c.N > 0 && nsop < 100 {
+		// The format specifiers here make sure that
+		// the ones digits line up for all three possible formats.
+		if nsop < 10 {
+			ns = fmt.Sprintf("%13.2f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
+		} else {
+			ns = fmt.Sprintf("%12.1f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
+		}
+	}
+	memStats := ""
+	if c.benchMem {
+		allocedBytes := fmt.Sprintf("%8d B/op", int64(c.netBytes)/int64(c.N))
+		allocs := fmt.Sprintf("%8d allocs/op", int64(c.netAllocs)/int64(c.N))
+		memStats = fmt.Sprintf("\t%s\t%s", allocedBytes, allocs)
+	}
+	return fmt.Sprintf("%8d\t%s%s%s", c.N, ns, mb, memStats)
+}
+
+func min(x, y int) int {
+	if x > y {
+		return y
+	}
+	return x
+}
+
+func max(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+// roundDown10 rounds a number down to the nearest power of 10.
+func roundDown10(n int) int {
+	var tens = 0
+	// tens = floor(log_10(n))
+	for n > 10 {
+		n = n / 10
+		tens++
+	}
+	// result = 10^tens
+	result := 1
+	for i := 0; i < tens; i++ {
+		result *= 10
+	}
+	return result
+}
+
+// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
+func roundUp(n int) int {
+	base := roundDown10(n)
+	if n < (2 * base) {
+		return 2 * base
+	}
+	if n < (5 * base) {
+		return 5 * base
+	}
+	return 10 * base
+}

=== added file 'internal/gopkg.in/check.v1/benchmark_test.go'
--- internal/gopkg.in/check.v1/benchmark_test.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/benchmark_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,91 @@
+// These tests verify the test running logic.
+
+package check_test
+
+import (
+	"time"
+	. "launchpad.net/crackly/internal/gopkg.in/check.v1"
+)
+
+var benchmarkS = Suite(&BenchmarkS{})
+
+type BenchmarkS struct{}
+
+func (s *BenchmarkS) TestCountSuite(c *C) {
+	suitesRun += 1
+}
+
+func (s *BenchmarkS) TestBasicTestTiming(c *C) {
+	helper := FixtureHelper{sleepOn: "Test1", sleep: 1000000 * time.Nanosecond}
+	output := String{}
+	runConf := RunConf{Output: &output, Verbose: true}
+	Run(&helper, &runConf)
+
+	expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test1\t0\\.001s\n" +
+		"PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t0\\.000s\n"
+	c.Assert(output.value, Matches, expected)
+}
+
+func (s *BenchmarkS) TestStreamTestTiming(c *C) {
+	helper := FixtureHelper{sleepOn: "SetUpSuite", sleep: 1000000 * time.Nanosecond}
+	output := String{}
+	runConf := RunConf{Output: &output, Stream: true}
+	Run(&helper, &runConf)
+
+	expected := "(?s).*\nPASS: check_test\\.go:[0-9]+: FixtureHelper\\.SetUpSuite\t *0\\.001s\n.*"
+	c.Assert(output.value, Matches, expected)
+}
+
+func (s *BenchmarkS) TestBenchmark(c *C) {
+	helper := FixtureHelper{sleep: 100000}
+	output := String{}
+	runConf := RunConf{
+		Output:        &output,
+		Benchmark:     true,
+		BenchmarkTime: 10000000,
+		Filter:        "Benchmark1",
+	}
+	Run(&helper, &runConf)
+	c.Check(helper.calls[0], Equals, "SetUpSuite")
+	c.Check(helper.calls[1], Equals, "SetUpTest")
+	c.Check(helper.calls[2], Equals, "Benchmark1")
+	c.Check(helper.calls[3], Equals, "TearDownTest")
+	c.Check(helper.calls[4], Equals, "SetUpTest")
+	c.Check(helper.calls[5], Equals, "Benchmark1")
+	c.Check(helper.calls[6], Equals, "TearDownTest")
+	// ... and more.
+
+	expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark1\t *100\t *[12][0-9]{5} ns/op\n"
+	c.Assert(output.value, Matches, expected)
+}
+
+func (s *BenchmarkS) TestBenchmarkBytes(c *C) {
+	helper := FixtureHelper{sleep: 100000}
+	output := String{}
+	runConf := RunConf{
+		Output:        &output,
+		Benchmark:     true,
+		BenchmarkTime: 10000000,
+		Filter:        "Benchmark2",
+	}
+	Run(&helper, &runConf)
+
+	expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark2\t *100\t *[12][0-9]{5} ns/op\t *[4-9]\\.[0-9]{2} MB/s\n"
+	c.Assert(output.value, Matches, expected)
+}
+
+func (s *BenchmarkS) TestBenchmarkMem(c *C) {
+	helper := FixtureHelper{sleep: 100000}
+	output := String{}
+	runConf := RunConf{
+		Output:        &output,
+		Benchmark:     true,
+		BenchmarkMem:  true,
+		BenchmarkTime: 10000000,
+		Filter:        "Benchmark3",
+	}
+	Run(&helper, &runConf)
+
+	expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark3\t *100\t *[12][0-9]{5} ns/op\t *[0-9]+ B/op\t *[1-9] allocs/op\n"
+	c.Assert(output.value, Matches, expected)
+}

=== added file 'internal/gopkg.in/check.v1/bootstrap_test.go'
--- internal/gopkg.in/check.v1/bootstrap_test.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/bootstrap_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,82 @@
+// These initial tests are for bootstrapping.  They verify that we can
+// basically use the testing infrastructure itself to check if the test
+// system is working.
+//
+// These tests use will break down the test runner badly in case of
+// errors because if they simply fail, we can't be sure the developer
+// will ever see anything (because failing means the failing system
+// somehow isn't working! :-)
+//
+// Do not assume *any* internal functionality works as expected besides
+// what's actually tested here.
+
+package check_test
+
+import (
+	"fmt"
+	"launchpad.net/crackly/internal/gopkg.in/check.v1"
+	"strings"
+)
+
+type BootstrapS struct{}
+
+var boostrapS = check.Suite(&BootstrapS{})
+
+func (s *BootstrapS) TestCountSuite(c *check.C) {
+	suitesRun += 1
+}
+
+func (s *BootstrapS) TestFailedAndFail(c *check.C) {
+	if c.Failed() {
+		critical("c.Failed() must be false first!")
+	}
+	c.Fail()
+	if !c.Failed() {
+		critical("c.Fail() didn't put the test in a failed state!")
+	}
+	c.Succeed()
+}
+
+func (s *BootstrapS) TestFailedAndSucceed(c *check.C) {
+	c.Fail()
+	c.Succeed()
+	if c.Failed() {
+		critical("c.Succeed() didn't put the test back in a non-failed state")
+	}
+}
+
+func (s *BootstrapS) TestLogAndGetTestLog(c *check.C) {
+	c.Log("Hello there!")
+	log := c.GetTestLog()
+	if log != "Hello there!\n" {
+		critical(fmt.Sprintf("Log() or GetTestLog() is not working! Got: %#v", log))
+	}
+}
+
+func (s *BootstrapS) TestLogfAndGetTestLog(c *check.C) {
+	c.Logf("Hello %v", "there!")
+	log := c.GetTestLog()
+	if log != "Hello there!\n" {
+		critical(fmt.Sprintf("Logf() or GetTestLog() is not working! Got: %#v", log))
+	}
+}
+
+func (s *BootstrapS) TestRunShowsErrors(c *check.C) {
+	output := String{}
+	check.Run(&FailHelper{}, &check.RunConf{Output: &output})
+	if strings.Index(output.value, "Expected failure!") == -1 {
+		critical(fmt.Sprintf("RunWithWriter() output did not contain the "+
+			"expected failure! Got: %#v",
+			output.value))
+	}
+}
+
+func (s *BootstrapS) TestRunDoesntShowSuccesses(c *check.C) {
+	output := String{}
+	check.Run(&SuccessHelper{}, &check.RunConf{Output: &output})
+	if strings.Index(output.value, "Expected success!") != -1 {
+		critical(fmt.Sprintf("RunWithWriter() output contained a successful "+
+			"test! Got: %#v",
+			output.value))
+	}
+}

=== added file 'internal/gopkg.in/check.v1/check.go'
--- internal/gopkg.in/check.v1/check.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/check.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,945 @@
+// Package check is a rich testing extension for Go's testing package.
+//
+// For details about the project, see:
+//
+//     http://labix.org/gocheck
+//
+package check
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// -----------------------------------------------------------------------
+// Internal type which deals with suite method calling.
+
+const (
+	fixtureKd = iota
+	testKd
+)
+
+type funcKind int
+
+const (
+	succeededSt = iota
+	failedSt
+	skippedSt
+	panickedSt
+	fixturePanickedSt
+	missedSt
+)
+
+type funcStatus int
+
+// A method value can't reach its own Method structure.
+type methodType struct {
+	reflect.Value
+	Info reflect.Method
+}
+
+func newMethod(receiver reflect.Value, i int) *methodType {
+	return &methodType{receiver.Method(i), receiver.Type().Method(i)}
+}
+
+func (method *methodType) PC() uintptr {
+	return method.Info.Func.Pointer()
+}
+
+func (method *methodType) suiteName() string {
+	t := method.Info.Type.In(0)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t.Name()
+}
+
+func (method *methodType) String() string {
+	return method.suiteName() + "." + method.Info.Name
+}
+
+func (method *methodType) matches(re *regexp.Regexp) bool {
+	return (re.MatchString(method.Info.Name) ||
+		re.MatchString(method.suiteName()) ||
+		re.MatchString(method.String()))
+}
+
+type C struct {
+	method    *methodType
+	kind      funcKind
+	testName  string
+	status    funcStatus
+	logb      *logger
+	logw      io.Writer
+	done      chan *C
+	reason    string
+	mustFail  bool
+	tempDir   *tempDir
+	benchMem  bool
+	startTime time.Time
+	timer
+}
+
+func (c *C) stopNow() {
+	runtime.Goexit()
+}
+
+// logger is a concurrency safe byte.Buffer
+type logger struct {
+	sync.Mutex
+	writer bytes.Buffer
+}
+
+func (l *logger) Write(buf []byte) (int, error) {
+	l.Lock()
+	defer l.Unlock()
+	return l.writer.Write(buf)
+}
+
+func (l *logger) WriteTo(w io.Writer) (int64, error) {
+	l.Lock()
+	defer l.Unlock()
+	return l.writer.WriteTo(w)
+}
+
+func (l *logger) String() string {
+	l.Lock()
+	defer l.Unlock()
+	return l.writer.String()
+}
+
+// -----------------------------------------------------------------------
+// Handling of temporary files and directories.
+
+type tempDir struct {
+	sync.Mutex
+	path    string
+	counter int
+}
+
+func (td *tempDir) newPath() string {
+	td.Lock()
+	defer td.Unlock()
+	if td.path == "" {
+		var err error
+		for i := 0; i != 100; i++ {
+			path := fmt.Sprintf("%s%ccheck-%d", os.TempDir(), os.PathSeparator, rand.Int())
+			if err = os.Mkdir(path, 0700); err == nil {
+				td.path = path
+				break
+			}
+		}
+		if td.path == "" {
+			panic("Couldn't create temporary directory: " + err.Error())
+		}
+	}
+	result := filepath.Join(td.path, strconv.Itoa(td.counter))
+	td.counter += 1
+	return result
+}
+
+func (td *tempDir) removeAll() {
+	td.Lock()
+	defer td.Unlock()
+	if td.path != "" {
+		err := os.RemoveAll(td.path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "WARNING: Error cleaning up temporaries: "+err.Error())
+		}
+	}
+}
+
+// Create a new temporary directory which is automatically removed after
+// the suite finishes running.
+func (c *C) MkDir() string {
+	path := c.tempDir.newPath()
+	if err := os.Mkdir(path, 0700); err != nil {
+		panic(fmt.Sprintf("Couldn't create temporary directory %s: %s", path, err.Error()))
+	}
+	return path
+}
+
+// -----------------------------------------------------------------------
+// Low-level logging functions.
+
+func (c *C) log(args ...interface{}) {
+	c.writeLog([]byte(fmt.Sprint(args...) + "\n"))
+}
+
+func (c *C) logf(format string, args ...interface{}) {
+	c.writeLog([]byte(fmt.Sprintf(format+"\n", args...)))
+}
+
+func (c *C) logNewLine() {
+	c.writeLog([]byte{'\n'})
+}
+
+func (c *C) writeLog(buf []byte) {
+	c.logb.Write(buf)
+	if c.logw != nil {
+		c.logw.Write(buf)
+	}
+}
+
+func hasStringOrError(x interface{}) (ok bool) {
+	_, ok = x.(fmt.Stringer)
+	if ok {
+		return
+	}
+	_, ok = x.(error)
+	return
+}
+
+func (c *C) logValue(label string, value interface{}) {
+	if label == "" {
+		if hasStringOrError(value) {
+			c.logf("... %#v (%q)", value, value)
+		} else {
+			c.logf("... %#v", value)
+		}
+	} else if value == nil {
+		c.logf("... %s = nil", label)
+	} else {
+		if hasStringOrError(value) {
+			fv := fmt.Sprintf("%#v", value)
+			qv := fmt.Sprintf("%q", value)
+			if fv != qv {
+				c.logf("... %s %s = %s (%s)", label, reflect.TypeOf(value), fv, qv)
+				return
+			}
+		}
+		if s, ok := value.(string); ok && isMultiLine(s) {
+			c.logf(`... %s %s = "" +`, label, reflect.TypeOf(value))
+			c.logMultiLine(s)
+		} else {
+			c.logf("... %s %s = %#v", label, reflect.TypeOf(value), value)
+		}
+	}
+}
+
+func (c *C) logMultiLine(s string) {
+	b := make([]byte, 0, len(s)*2)
+	i := 0
+	n := len(s)
+	for i < n {
+		j := i + 1
+		for j < n && s[j-1] != '\n' {
+			j++
+		}
+		b = append(b, "...     "...)
+		b = strconv.AppendQuote(b, s[i:j])
+		if j < n {
+			b = append(b, " +"...)
+		}
+		b = append(b, '\n')
+		i = j
+	}
+	c.writeLog(b)
+}
+
+func isMultiLine(s string) bool {
+	for i := 0; i+1 < len(s); i++ {
+		if s[i] == '\n' {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *C) logString(issue string) {
+	c.log("... ", issue)
+}
+
+func (c *C) logCaller(skip int) {
+	// This is a bit heavier than it ought to be.
+	skip += 1 // Our own frame.
+	pc, callerFile, callerLine, ok := runtime.Caller(skip)
+	if !ok {
+		return
+	}
+	var testFile string
+	var testLine int
+	testFunc := runtime.FuncForPC(c.method.PC())
+	if runtime.FuncForPC(pc) != testFunc {
+		for {
+			skip += 1
+			if pc, file, line, ok := runtime.Caller(skip); ok {
+				// Note that the test line may be different on
+				// distinct calls for the same test.  Showing
+				// the "internal" line is helpful when debugging.
+				if runtime.FuncForPC(pc) == testFunc {
+					testFile, testLine = file, line
+					break
+				}
+			} else {
+				break
+			}
+		}
+	}
+	if testFile != "" && (testFile != callerFile || testLine != callerLine) {
+		c.logCode(testFile, testLine)
+	}
+	c.logCode(callerFile, callerLine)
+}
+
+func (c *C) logCode(path string, line int) {
+	c.logf("%s:%d:", nicePath(path), line)
+	code, err := printLine(path, line)
+	if code == "" {
+		code = "..." // XXX Open the file and take the raw line.
+		if err != nil {
+			code += err.Error()
+		}
+	}
+	c.log(indent(code, "    "))
+}
+
+var valueGo = filepath.Join("reflect", "value.go")
+var asmGo = filepath.Join("runtime", "asm_")
+
+func (c *C) logPanic(skip int, value interface{}) {
+	skip++ // Our own frame.
+	initialSkip := skip
+	for ; ; skip++ {
+		if pc, file, line, ok := runtime.Caller(skip); ok {
+			if skip == initialSkip {
+				c.logf("... Panic: %s (PC=0x%X)\n", value, pc)
+			}
+			name := niceFuncName(pc)
+			path := nicePath(file)
+			if strings.Contains(path, "/gopkg.in/check.v") {
+				continue
+			}
+			if name == "Value.call" && strings.HasSuffix(path, valueGo) {
+				continue
+			}
+			if name == "call16" && strings.Contains(path, asmGo) {
+				continue
+			}
+			c.logf("%s:%d\n  in %s", nicePath(file), line, name)
+		} else {
+			break
+		}
+	}
+}
+
+func (c *C) logSoftPanic(issue string) {
+	c.log("... Panic: ", issue)
+}
+
+func (c *C) logArgPanic(method *methodType, expectedType string) {
+	c.logf("... Panic: %s argument should be %s",
+		niceFuncName(method.PC()), expectedType)
+}
+
+// -----------------------------------------------------------------------
+// Some simple formatting helpers.
+
+var initWD, initWDErr = os.Getwd()
+
+func init() {
+	if initWDErr == nil {
+		initWD = strings.Replace(initWD, "\\", "/", -1) + "/"
+	}
+}
+
+func nicePath(path string) string {
+	if initWDErr == nil {
+		if strings.HasPrefix(path, initWD) {
+			return path[len(initWD):]
+		}
+	}
+	return path
+}
+
+func niceFuncPath(pc uintptr) string {
+	function := runtime.FuncForPC(pc)
+	if function != nil {
+		filename, line := function.FileLine(pc)
+		return fmt.Sprintf("%s:%d", nicePath(filename), line)
+	}
+	return "<unknown path>"
+}
+
+func niceFuncName(pc uintptr) string {
+	function := runtime.FuncForPC(pc)
+	if function != nil {
+		name := path.Base(function.Name())
+		if i := strings.Index(name, "."); i > 0 {
+			name = name[i+1:]
+		}
+		if strings.HasPrefix(name, "(*") {
+			if i := strings.Index(name, ")"); i > 0 {
+				name = name[2:i] + name[i+1:]
+			}
+		}
+		if i := strings.LastIndex(name, ".*"); i != -1 {
+			name = name[:i] + "." + name[i+2:]
+		}
+		if i := strings.LastIndex(name, "·"); i != -1 {
+			name = name[:i] + "." + name[i+2:]
+		}
+		return name
+	}
+	return "<unknown function>"
+}
+
+// -----------------------------------------------------------------------
+// Result tracker to aggregate call results.
+
+type Result struct {
+	Succeeded        int
+	Failed           int
+	Skipped          int
+	Panicked         int
+	FixturePanicked  int
+	ExpectedFailures int
+	Missed           int    // Not even tried to run, related to a panic in the fixture.
+	RunError         error  // Houston, we've got a problem.
+	WorkDir          string // If KeepWorkDir is true
+}
+
+type resultTracker struct {
+	result          Result
+	_lastWasProblem bool
+	_waiting        int
+	_missed         int
+	_expectChan     chan *C
+	_doneChan       chan *C
+	_stopChan       chan bool
+}
+
+func newResultTracker() *resultTracker {
+	return &resultTracker{_expectChan: make(chan *C), // Synchronous
+		_doneChan: make(chan *C, 32), // Asynchronous
+		_stopChan: make(chan bool)}   // Synchronous
+}
+
+func (tracker *resultTracker) start() {
+	go tracker._loopRoutine()
+}
+
+func (tracker *resultTracker) waitAndStop() {
+	<-tracker._stopChan
+}
+
+func (tracker *resultTracker) expectCall(c *C) {
+	tracker._expectChan <- c
+}
+
+func (tracker *resultTracker) callDone(c *C) {
+	tracker._doneChan <- c
+}
+
+func (tracker *resultTracker) _loopRoutine() {
+	for {
+		var c *C
+		if tracker._waiting > 0 {
+			// Calls still running. Can't stop.
+			select {
+			// XXX Reindent this (not now to make diff clear)
+			case c = <-tracker._expectChan:
+				tracker._waiting += 1
+			case c = <-tracker._doneChan:
+				tracker._waiting -= 1
+				switch c.status {
+				case succeededSt:
+					if c.kind == testKd {
+						if c.mustFail {
+							tracker.result.ExpectedFailures++
+						} else {
+							tracker.result.Succeeded++
+						}
+					}
+				case failedSt:
+					tracker.result.Failed++
+				case panickedSt:
+					if c.kind == fixtureKd {
+						tracker.result.FixturePanicked++
+					} else {
+						tracker.result.Panicked++
+					}
+				case fixturePanickedSt:
+					// Track it as missed, since the panic
+					// was on the fixture, not on the test.
+					tracker.result.Missed++
+				case missedSt:
+					tracker.result.Missed++
+				case skippedSt:
+					if c.kind == testKd {
+						tracker.result.Skipped++
+					}
+				}
+			}
+		} else {
+			// No calls.  Can stop, but no done calls here.
+			select {
+			case tracker._stopChan <- true:
+				return
+			case c = <-tracker._expectChan:
+				tracker._waiting += 1
+			case c = <-tracker._doneChan:
+				panic("Tracker got an unexpected done call.")
+			}
+		}
+	}
+}
+
+// -----------------------------------------------------------------------
+// The underlying suite runner.
+
+type suiteRunner struct {
+	suite                     interface{}
+	setUpSuite, tearDownSuite *methodType
+	setUpTest, tearDownTest   *methodType
+	tests                     []*methodType
+	tracker                   *resultTracker
+	tempDir                   *tempDir
+	keepDir                   bool
+	output                    *outputWriter
+	reportedProblemLast       bool
+	benchTime                 time.Duration
+	benchMem                  bool
+}
+
+type RunConf struct {
+	Output        io.Writer
+	Stream        bool
+	Verbose       bool
+	Filter        string
+	Benchmark     bool
+	BenchmarkTime time.Duration // Defaults to 1 second
+	BenchmarkMem  bool
+	KeepWorkDir   bool
+}
+
+// Create a new suiteRunner able to run all methods in the given suite.
+func newSuiteRunner(suite interface{}, runConf *RunConf) *suiteRunner {
+	var conf RunConf
+	if runConf != nil {
+		conf = *runConf
+	}
+	if conf.Output == nil {
+		conf.Output = os.Stdout
+	}
+	if conf.Benchmark {
+		conf.Verbose = true
+	}
+
+	suiteType := reflect.TypeOf(suite)
+	suiteNumMethods := suiteType.NumMethod()
+	suiteValue := reflect.ValueOf(suite)
+
+	runner := &suiteRunner{
+		suite:     suite,
+		output:    newOutputWriter(conf.Output, conf.Stream, conf.Verbose),
+		tracker:   newResultTracker(),
+		benchTime: conf.BenchmarkTime,
+		benchMem:  conf.BenchmarkMem,
+		tempDir:   &tempDir{},
+		keepDir:   conf.KeepWorkDir,
+		tests:     make([]*methodType, 0, suiteNumMethods),
+	}
+	if runner.benchTime == 0 {
+		runner.benchTime = 1 * time.Second
+	}
+
+	var filterRegexp *regexp.Regexp
+	if conf.Filter != "" {
+		if regexp, err := regexp.Compile(conf.Filter); err != nil {
+			msg := "Bad filter expression: " + err.Error()
+			runner.tracker.result.RunError = errors.New(msg)
+			return runner
+		} else {
+			filterRegexp = regexp
+		}
+	}
+
+	for i := 0; i != suiteNumMethods; i++ {
+		method := newMethod(suiteValue, i)
+		switch method.Info.Name {
+		case "SetUpSuite":
+			runner.setUpSuite = method
+		case "TearDownSuite":
+			runner.tearDownSuite = method
+		case "SetUpTest":
+			runner.setUpTest = method
+		case "TearDownTest":
+			runner.tearDownTest = method
+		default:
+			prefix := "Test"
+			if conf.Benchmark {
+				prefix = "Benchmark"
+			}
+			if !strings.HasPrefix(method.Info.Name, prefix) {
+				continue
+			}
+			if filterRegexp == nil || method.matches(filterRegexp) {
+				runner.tests = append(runner.tests, method)
+			}
+		}
+	}
+	return runner
+}
+
+// Run all methods in the given suite.
+func (runner *suiteRunner) run() *Result {
+	if runner.tracker.result.RunError == nil && len(runner.tests) > 0 {
+		runner.tracker.start()
+		if runner.checkFixtureArgs() {
+			c := runner.runFixture(runner.setUpSuite, "", nil)
+			if c == nil || c.status == succeededSt {
+				for i := 0; i != len(runner.tests); i++ {
+					c := runner.runTest(runner.tests[i])
+					if c.status == fixturePanickedSt {
+						runner.skipTests(missedSt, runner.tests[i+1:])
+						break
+					}
+				}
+			} else if c != nil && c.status == skippedSt {
+				runner.skipTests(skippedSt, runner.tests)
+			} else {
+				runner.skipTests(missedSt, runner.tests)
+			}
+			runner.runFixture(runner.tearDownSuite, "", nil)
+		} else {
+			runner.skipTests(missedSt, runner.tests)
+		}
+		runner.tracker.waitAndStop()
+		if runner.keepDir {
+			runner.tracker.result.WorkDir = runner.tempDir.path
+		} else {
+			runner.tempDir.removeAll()
+		}
+	}
+	return &runner.tracker.result
+}
+
+// Create a call object with the given suite method, and fork a
+// goroutine with the provided dispatcher for running it.
+func (runner *suiteRunner) forkCall(method *methodType, kind funcKind, testName string, logb *logger, dispatcher func(c *C)) *C {
+	var logw io.Writer
+	if runner.output.Stream {
+		logw = runner.output
+	}
+	if logb == nil {
+		logb = new(logger)
+	}
+	c := &C{
+		method:    method,
+		kind:      kind,
+		testName:  testName,
+		logb:      logb,
+		logw:      logw,
+		tempDir:   runner.tempDir,
+		done:      make(chan *C, 1),
+		timer:     timer{benchTime: runner.benchTime},
+		startTime: time.Now(),
+		benchMem:  runner.benchMem,
+	}
+	runner.tracker.expectCall(c)
+	go (func() {
+		runner.reportCallStarted(c)
+		defer runner.callDone(c)
+		dispatcher(c)
+	})()
+	return c
+}
+
+// Same as forkCall(), but wait for call to finish before returning.
+func (runner *suiteRunner) runFunc(method *methodType, kind funcKind, testName string, logb *logger, dispatcher func(c *C)) *C {
+	c := runner.forkCall(method, kind, testName, logb, dispatcher)
+	<-c.done
+	return c
+}
+
+// Handle a finished call.  If there were any panics, update the call status
+// accordingly.  Then, mark the call as done and report to the tracker.
+func (runner *suiteRunner) callDone(c *C) {
+	value := recover()
+	if value != nil {
+		switch v := value.(type) {
+		case *fixturePanic:
+			if v.status == skippedSt {
+				c.status = skippedSt
+			} else {
+				c.logSoftPanic("Fixture has panicked (see related PANIC)")
+				c.status = fixturePanickedSt
+			}
+		default:
+			c.logPanic(1, value)
+			c.status = panickedSt
+		}
+	}
+	if c.mustFail {
+		switch c.status {
+		case failedSt:
+			c.status = succeededSt
+		case succeededSt:
+			c.status = failedSt
+			c.logString("Error: Test succeeded, but was expected to fail")
+			c.logString("Reason: " + c.reason)
+		}
+	}
+
+	runner.reportCallDone(c)
+	c.done <- c
+}
+
+// Runs a fixture call synchronously.  The fixture will still be run in a
+// goroutine like all suite methods, but this method will not return
+// while the fixture goroutine is not done, because the fixture must be
+// run in a desired order.
+func (runner *suiteRunner) runFixture(method *methodType, testName string, logb *logger) *C {
+	if method != nil {
+		c := runner.runFunc(method, fixtureKd, testName, logb, func(c *C) {
+			c.ResetTimer()
+			c.StartTimer()
+			defer c.StopTimer()
+			c.method.Call([]reflect.Value{reflect.ValueOf(c)})
+		})
+		return c
+	}
+	return nil
+}
+
+// Run the fixture method with runFixture(), but panic with a fixturePanic{}
+// in case the fixture method panics.  This makes it easier to track the
+// fixture panic together with other call panics within forkTest().
+func (runner *suiteRunner) runFixtureWithPanic(method *methodType, testName string, logb *logger, skipped *bool) *C {
+	if skipped != nil && *skipped {
+		return nil
+	}
+	c := runner.runFixture(method, testName, logb)
+	if c != nil && c.status != succeededSt {
+		if skipped != nil {
+			*skipped = c.status == skippedSt
+		}
+		panic(&fixturePanic{c.status, method})
+	}
+	return c
+}
+
+type fixturePanic struct {
+	status funcStatus
+	method *methodType
+}
+
+// Run the suite test method, together with the test-specific fixture,
+// asynchronously.
+func (runner *suiteRunner) forkTest(method *methodType) *C {
+	testName := method.String()
+	return runner.forkCall(method, testKd, testName, nil, func(c *C) {
+		var skipped bool
+		defer runner.runFixtureWithPanic(runner.tearDownTest, testName, nil, &skipped)
+		defer c.StopTimer()
+		benchN := 1
+		for {
+			runner.runFixtureWithPanic(runner.setUpTest, testName, c.logb, &skipped)
+			mt := c.method.Type()
+			if mt.NumIn() != 1 || mt.In(0) != reflect.TypeOf(c) {
+				// Rather than a plain panic, provide a more helpful message when
+				// the argument type is incorrect.
+				c.status = panickedSt
+				c.logArgPanic(c.method, "*check.C")
+				return
+			}
+			if strings.HasPrefix(c.method.Info.Name, "Test") {
+				c.ResetTimer()
+				c.StartTimer()
+				c.method.Call([]reflect.Value{reflect.ValueOf(c)})
+				return
+			}
+			if !strings.HasPrefix(c.method.Info.Name, "Benchmark") {
+				panic("unexpected method prefix: " + c.method.Info.Name)
+			}
+
+			runtime.GC()
+			c.N = benchN
+			c.ResetTimer()
+			c.StartTimer()
+			c.method.Call([]reflect.Value{reflect.ValueOf(c)})
+			c.StopTimer()
+			if c.status != succeededSt || c.duration >= c.benchTime || benchN >= 1e9 {
+				return
+			}
+			perOpN := int(1e9)
+			if c.nsPerOp() != 0 {
+				perOpN = int(c.benchTime.Nanoseconds() / c.nsPerOp())
+			}
+
+			// Logic taken from the stock testing package:
+			// - Run more iterations than we think we'll need for a second (1.5x).
+			// - Don't grow too fast in case we had timing errors previously.
+			// - Be sure to run at least one more than last time.
+			benchN = max(min(perOpN+perOpN/2, 100*benchN), benchN+1)
+			benchN = roundUp(benchN)
+
+			skipped = true // Don't run the deferred one if this panics.
+			runner.runFixtureWithPanic(runner.tearDownTest, testName, nil, nil)
+			skipped = false
+		}
+	})
+}
+
+// Same as forkTest(), but wait for the test to finish before returning.
+func (runner *suiteRunner) runTest(method *methodType) *C {
+	c := runner.forkTest(method)
+	<-c.done
+	return c
+}
+
+// Helper to mark tests as skipped or missed.  A bit heavy for what
+// it does, but it enables homogeneous handling of tracking, including
+// nice verbose output.
+func (runner *suiteRunner) skipTests(status funcStatus, methods []*methodType) {
+	for _, method := range methods {
+		runner.runFunc(method, testKd, "", nil, func(c *C) {
+			c.status = status
+		})
+	}
+}
+
+// Verify if the fixture arguments are *check.C.  In case of errors,
+// log the error as a panic in the fixture method call, and return false.
+func (runner *suiteRunner) checkFixtureArgs() bool {
+	succeeded := true
+	argType := reflect.TypeOf(&C{})
+	for _, method := range []*methodType{runner.setUpSuite, runner.tearDownSuite, runner.setUpTest, runner.tearDownTest} {
+		if method != nil {
+			mt := method.Type()
+			if mt.NumIn() != 1 || mt.In(0) != argType {
+				succeeded = false
+				runner.runFunc(method, fixtureKd, "", nil, func(c *C) {
+					c.logArgPanic(method, "*check.C")
+					c.status = panickedSt
+				})
+			}
+		}
+	}
+	return succeeded
+}
+
+func (runner *suiteRunner) reportCallStarted(c *C) {
+	runner.output.WriteCallStarted("START", c)
+}
+
+func (runner *suiteRunner) reportCallDone(c *C) {
+	runner.tracker.callDone(c)
+	switch c.status {
+	case succeededSt:
+		if c.mustFail {
+			runner.output.WriteCallSuccess("FAIL EXPECTED", c)
+		} else {
+			runner.output.WriteCallSuccess("PASS", c)
+		}
+	case skippedSt:
+		runner.output.WriteCallSuccess("SKIP", c)
+	case failedSt:
+		runner.output.WriteCallProblem("FAIL", c)
+	case panickedSt:
+		runner.output.WriteCallProblem("PANIC", c)
+	case fixturePanickedSt:
+		// That's a testKd call reporting that its fixture
+		// has panicked. The fixture call which caused the
+		// panic itself was tracked above. We'll report to
+		// aid debugging.
+		runner.output.WriteCallProblem("PANIC", c)
+	case missedSt:
+		runner.output.WriteCallSuccess("MISS", c)
+	}
+}
+
+// -----------------------------------------------------------------------
+// Output writer manages atomic output writing according to settings.
+
+type outputWriter struct {
+	m                    sync.Mutex
+	writer               io.Writer
+	wroteCallProblemLast bool
+	Stream               bool
+	Verbose              bool
+}
+
+func newOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {
+	return &outputWriter{writer: writer, Stream: stream, Verbose: verbose}
+}
+
+func (ow *outputWriter) Write(content []byte) (n int, err error) {
+	ow.m.Lock()
+	n, err = ow.writer.Write(content)
+	ow.m.Unlock()
+	return
+}
+
+func (ow *outputWriter) WriteCallStarted(label string, c *C) {
+	if ow.Stream {
+		header := renderCallHeader(label, c, "", "\n")
+		ow.m.Lock()
+		ow.writer.Write([]byte(header))
+		ow.m.Unlock()
+	}
+}
+
+func (ow *outputWriter) WriteCallProblem(label string, c *C) {
+	var prefix string
+	if !ow.Stream {
+		prefix = "\n-----------------------------------" +
+			"-----------------------------------\n"
+	}
+	header := renderCallHeader(label, c, prefix, "\n\n")
+	ow.m.Lock()
+	ow.wroteCallProblemLast = true
+	ow.writer.Write([]byte(header))
+	if !ow.Stream {
+		c.logb.WriteTo(ow.writer)
+	}
+	ow.m.Unlock()
+}
+
+func (ow *outputWriter) WriteCallSuccess(label string, c *C) {
+	if ow.Stream || (ow.Verbose && c.kind == testKd) {
+		// TODO Use a buffer here.
+		var suffix string
+		if c.reason != "" {
+			suffix = " (" + c.reason + ")"
+		}
+		if c.status == succeededSt {
+			suffix += "\t" + c.timerString()
+		}
+		suffix += "\n"
+		if ow.Stream {
+			suffix += "\n"
+		}
+		header := renderCallHeader(label, c, "", suffix)
+		ow.m.Lock()
+		// Resist temptation of using line as prefix above due to race.
+		if !ow.Stream && ow.wroteCallProblemLast {
+			header = "\n-----------------------------------" +
+				"-----------------------------------\n" +
+				header
+		}
+		ow.wroteCallProblemLast = false
+		ow.writer.Write([]byte(header))
+		ow.m.Unlock()
+	}
+}
+
+func renderCallHeader(label string, c *C, prefix, suffix string) string {
+	pc := c.method.PC()
+	return fmt.Sprintf("%s%s: %s: %s%s", prefix, label, niceFuncPath(pc),
+		niceFuncName(pc), suffix)
+}

=== added file 'internal/gopkg.in/check.v1/check_test.go'
--- internal/gopkg.in/check.v1/check_test.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/check_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,207 @@
+// This file contains just a few generic helpers which are used by the
+// other test files.
+
+package check_test
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"runtime"
+	"testing"
+	"time"
+
+	"launchpad.net/crackly/internal/gopkg.in/check.v1"
+)
+
+// We count the number of suites run at least to get a vague hint that the
+// test suite is behaving as it should.  Otherwise a bug introduced at the
+// very core of the system could go unperceived.
+const suitesRunExpected = 8
+
+var suitesRun int = 0
+
+func Test(t *testing.T) {
+	check.TestingT(t)
+	if suitesRun != suitesRunExpected && flag.Lookup("check.f").Value.String() == "" {
+		critical(fmt.Sprintf("Expected %d suites to run rather than %d",
+			suitesRunExpected, suitesRun))
+	}
+}
+
+// -----------------------------------------------------------------------
+// Helper functions.
+
+// Break down badly.  This is used in test cases which can't yet assume
+// that the fundamental bits are working.
+func critical(error string) {
+	fmt.Fprintln(os.Stderr, "CRITICAL: "+error)
+	os.Exit(1)
+}
+
+// Return the file line where it's called.
+func getMyLine() int {
+	if _, _, line, ok := runtime.Caller(1); ok {
+		return line
+	}
+	return -1
+}
+
+// -----------------------------------------------------------------------
+// Helper type implementing a basic io.Writer for testing output.
+
+// Type implementing the io.Writer interface for analyzing output.
+type String struct {
+	value string
+}
+
+// The only function required by the io.Writer interface.  Will append
+// written data to the String.value string.
+func (s *String) Write(p []byte) (n int, err error) {
+	s.value += string(p)
+	return len(p), nil
+}
+
+// Trivial wrapper to test errors happening on a different file
+// than the test itself.
+func checkEqualWrapper(c *check.C, obtained, expected interface{}) (result bool, line int) {
+	return c.Check(obtained, check.Equals, expected), getMyLine()
+}
+
+// -----------------------------------------------------------------------
+// Helper suite for testing basic fail behavior.
+
+type FailHelper struct {
+	testLine int
+}
+
+func (s *FailHelper) TestLogAndFail(c *check.C) {
+	s.testLine = getMyLine() - 1
+	c.Log("Expected failure!")
+	c.Fail()
+}
+
+// -----------------------------------------------------------------------
+// Helper suite for testing basic success behavior.
+
+type SuccessHelper struct{}
+
+func (s *SuccessHelper) TestLogAndSucceed(c *check.C) {
+	c.Log("Expected success!")
+}
+
+// -----------------------------------------------------------------------
+// Helper suite for testing ordering and behavior of fixture.
+
+type FixtureHelper struct {
+	calls   []string
+	panicOn string
+	skip    bool
+	skipOnN int
+	sleepOn string
+	sleep   time.Duration
+	bytes   int64
+}
+
+func (s *FixtureHelper) trace(name string, c *check.C) {
+	s.calls = append(s.calls, name)
+	if name == s.panicOn {
+		panic(name)
+	}
+	if s.sleep > 0 && s.sleepOn == name {
+		time.Sleep(s.sleep)
+	}
+	if s.skip && s.skipOnN == len(s.calls)-1 {
+		c.Skip("skipOnN == n")
+	}
+}
+
+func (s *FixtureHelper) SetUpSuite(c *check.C) {
+	s.trace("SetUpSuite", c)
+}
+
+func (s *FixtureHelper) TearDownSuite(c *check.C) {
+	s.trace("TearDownSuite", c)
+}
+
+func (s *FixtureHelper) SetUpTest(c *check.C) {
+	s.trace("SetUpTest", c)
+}
+
+func (s *FixtureHelper) TearDownTest(c *check.C) {
+	s.trace("TearDownTest", c)
+}
+
+func (s *FixtureHelper) Test1(c *check.C) {
+	s.trace("Test1", c)
+}
+
+func (s *FixtureHelper) Test2(c *check.C) {
+	s.trace("Test2", c)
+}
+
+func (s *FixtureHelper) Benchmark1(c *check.C) {
+	s.trace("Benchmark1", c)
+	for i := 0; i < c.N; i++ {
+		time.Sleep(s.sleep)
+	}
+}
+
+func (s *FixtureHelper) Benchmark2(c *check.C) {
+	s.trace("Benchmark2", c)
+	c.SetBytes(1024)
+	for i := 0; i < c.N; i++ {
+		time.Sleep(s.sleep)
+	}
+}
+
+func (s *FixtureHelper) Benchmark3(c *check.C) {
+	var x []int64
+	s.trace("Benchmark3", c)
+	for i := 0; i < c.N; i++ {
+		time.Sleep(s.sleep)
+		x = make([]int64, 5)
+		_ = x
+	}
+}
+
+// -----------------------------------------------------------------------
+// Helper which checks the state of the test and ensures that it matches
+// the given expectations.  Depends on c.Errorf() working, so shouldn't
+// be used to test this one function.
+
+type expectedState struct {
+	name   string
+	result interface{}
+	failed bool
+	log    string
+}
+
+// Verify the state of the test.  Note that since this also verifies if
+// the test is supposed to be in a failed state, no other checks should
+// be done in addition to what is being tested.
+func checkState(c *check.C, result interface{}, expected *expectedState) {
+	failed := c.Failed()
+	c.Succeed()
+	log := c.GetTestLog()
+	matched, matchError := regexp.MatchString("^"+expected.log+"$", log)
+	if matchError != nil {
+		c.Errorf("Error in matching expression used in testing %s",
+			expected.name)
+	} else if !matched {
+		c.Errorf("%s logged:\n----------\n%s----------\n\nExpected:\n----------\n%s\n----------",
+			expected.name, log, expected.log)
+	}
+	if result != expected.result {
+		c.Errorf("%s returned %#v rather than %#v",
+			expected.name, result, expected.result)
+	}
+	if failed != expected.failed {
+		if failed {
+			c.Errorf("%s has failed when it shouldn't", expected.name)
+		} else {
+			c.Errorf("%s has not failed when it should", expected.name)
+		}
+	}
+}

=== added file 'internal/gopkg.in/check.v1/checkers.go'
--- internal/gopkg.in/check.v1/checkers.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/checkers.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,458 @@
+package check
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+)
+
+// -----------------------------------------------------------------------
+// CommentInterface and Commentf helper, to attach extra information to checks.
+
+type comment struct {
+	format string
+	args   []interface{}
+}
+
+// Commentf returns an infomational value to use with Assert or Check calls.
+// If the checker test fails, the provided arguments will be passed to
+// fmt.Sprintf, and will be presented next to the logged failure.
+//
+// For example:
+//
+//     c.Assert(v, Equals, 42, Commentf("Iteration #%d failed.", i))
+//
+// Note that if the comment is constant, a better option is to
+// simply use a normal comment right above or next to the line, as
+// it will also get printed with any errors:
+//
+//     c.Assert(l, Equals, 8192) // Ensure buffer size is correct (bug #123)
+//
+func Commentf(format string, args ...interface{}) CommentInterface {
+	return &comment{format, args}
+}
+
+// CommentInterface must be implemented by types that attach extra
+// information to failed checks. See the Commentf function for details.
+type CommentInterface interface {
+	CheckCommentString() string
+}
+
+func (c *comment) CheckCommentString() string {
+	return fmt.Sprintf(c.format, c.args...)
+}
+
+// -----------------------------------------------------------------------
+// The Checker interface.
+
+// The Checker interface must be provided by checkers used with
+// the Assert and Check verification methods.
+type Checker interface {
+	Info() *CheckerInfo
+	Check(params []interface{}, names []string) (result bool, error string)
+}
+
+// See the Checker interface.
+type CheckerInfo struct {
+	Name   string
+	Params []string
+}
+
+func (info *CheckerInfo) Info() *CheckerInfo {
+	return info
+}
+
+// -----------------------------------------------------------------------
+// Not checker logic inverter.
+
+// The Not checker inverts the logic of the provided checker.  The
+// resulting checker will succeed where the original one failed, and
+// vice-versa.
+//
+// For example:
+//
+//     c.Assert(a, Not(Equals), b)
+//
+func Not(checker Checker) Checker {
+	return &notChecker{checker}
+}
+
+type notChecker struct {
+	sub Checker
+}
+
+func (checker *notChecker) Info() *CheckerInfo {
+	info := *checker.sub.Info()
+	info.Name = "Not(" + info.Name + ")"
+	return &info
+}
+
+func (checker *notChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	result, error = checker.sub.Check(params, names)
+	result = !result
+	return
+}
+
+// -----------------------------------------------------------------------
+// IsNil checker.
+
+type isNilChecker struct {
+	*CheckerInfo
+}
+
+// The IsNil checker tests whether the obtained value is nil.
+//
+// For example:
+//
+//    c.Assert(err, IsNil)
+//
+var IsNil Checker = &isNilChecker{
+	&CheckerInfo{Name: "IsNil", Params: []string{"value"}},
+}
+
+func (checker *isNilChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	return isNil(params[0]), ""
+}
+
+func isNil(obtained interface{}) (result bool) {
+	if obtained == nil {
+		result = true
+	} else {
+		switch v := reflect.ValueOf(obtained); v.Kind() {
+		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+			return v.IsNil()
+		}
+	}
+	return
+}
+
+// -----------------------------------------------------------------------
+// NotNil checker. Alias for Not(IsNil), since it's so common.
+
+type notNilChecker struct {
+	*CheckerInfo
+}
+
+// The NotNil checker verifies that the obtained value is not nil.
+//
+// For example:
+//
+//     c.Assert(iface, NotNil)
+//
+// This is an alias for Not(IsNil), made available since it's a
+// fairly common check.
+//
+var NotNil Checker = &notNilChecker{
+	&CheckerInfo{Name: "NotNil", Params: []string{"value"}},
+}
+
+func (checker *notNilChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	return !isNil(params[0]), ""
+}
+
+// -----------------------------------------------------------------------
+// Equals checker.
+
+type equalsChecker struct {
+	*CheckerInfo
+}
+
+// The Equals checker verifies that the obtained value is equal to
+// the expected value, according to usual Go semantics for ==.
+//
+// For example:
+//
+//     c.Assert(value, Equals, 42)
+//
+var Equals Checker = &equalsChecker{
+	&CheckerInfo{Name: "Equals", Params: []string{"obtained", "expected"}},
+}
+
+func (checker *equalsChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	defer func() {
+		if v := recover(); v != nil {
+			result = false
+			error = fmt.Sprint(v)
+		}
+	}()
+	return params[0] == params[1], ""
+}
+
+// -----------------------------------------------------------------------
+// DeepEquals checker.
+
+type deepEqualsChecker struct {
+	*CheckerInfo
+}
+
+// The DeepEquals checker verifies that the obtained value is deep-equal to
+// the expected value.  The check will work correctly even when facing
+// slices, interfaces, and values of different types (which always fail
+// the test).
+//
+// For example:
+//
+//     c.Assert(value, DeepEquals, 42)
+//     c.Assert(array, DeepEquals, []string{"hi", "there"})
+//
+var DeepEquals Checker = &deepEqualsChecker{
+	&CheckerInfo{Name: "DeepEquals", Params: []string{"obtained", "expected"}},
+}
+
+func (checker *deepEqualsChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	return reflect.DeepEqual(params[0], params[1]), ""
+}
+
+// -----------------------------------------------------------------------
+// HasLen checker.
+
+type hasLenChecker struct {
+	*CheckerInfo
+}
+
+// The HasLen checker verifies that the obtained value has the
+// provided length. In many cases this is superior to using Equals
+// in conjuction with the len function because in case the check
+// fails the value itself will be printed, instead of its length,
+// providing more details for figuring the problem.
+//
+// For example:
+//
+//     c.Assert(list, HasLen, 5)
+//
+var HasLen Checker = &hasLenChecker{
+	&CheckerInfo{Name: "HasLen", Params: []string{"obtained", "n"}},
+}
+
+func (checker *hasLenChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	n, ok := params[1].(int)
+	if !ok {
+		return false, "n must be an int"
+	}
+	value := reflect.ValueOf(params[0])
+	switch value.Kind() {
+	case reflect.Map, reflect.Array, reflect.Slice, reflect.Chan, reflect.String:
+	default:
+		return false, "obtained value type has no length"
+	}
+	return value.Len() == n, ""
+}
+
+// -----------------------------------------------------------------------
+// ErrorMatches checker.
+
+type errorMatchesChecker struct {
+	*CheckerInfo
+}
+
+// The ErrorMatches checker verifies that the error value
+// is non nil and matches the regular expression provided.
+//
+// For example:
+//
+//     c.Assert(err, ErrorMatches, "perm.*denied")
+//
+var ErrorMatches Checker = errorMatchesChecker{
+	&CheckerInfo{Name: "ErrorMatches", Params: []string{"value", "regex"}},
+}
+
+func (checker errorMatchesChecker) Check(params []interface{}, names []string) (result bool, errStr string) {
+	if params[0] == nil {
+		return false, "Error value is nil"
+	}
+	err, ok := params[0].(error)
+	if !ok {
+		return false, "Value is not an error"
+	}
+	params[0] = err.Error()
+	names[0] = "error"
+	return matches(params[0], params[1])
+}
+
+// -----------------------------------------------------------------------
+// Matches checker.
+
+type matchesChecker struct {
+	*CheckerInfo
+}
+
+// The Matches checker verifies that the string provided as the obtained
+// value (or the string resulting from obtained.String()) matches the
+// regular expression provided.
+//
+// For example:
+//
+//     c.Assert(err, Matches, "perm.*denied")
+//
+var Matches Checker = &matchesChecker{
+	&CheckerInfo{Name: "Matches", Params: []string{"value", "regex"}},
+}
+
+func (checker *matchesChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	return matches(params[0], params[1])
+}
+
+func matches(value, regex interface{}) (result bool, error string) {
+	reStr, ok := regex.(string)
+	if !ok {
+		return false, "Regex must be a string"
+	}
+	valueStr, valueIsStr := value.(string)
+	if !valueIsStr {
+		if valueWithStr, valueHasStr := value.(fmt.Stringer); valueHasStr {
+			valueStr, valueIsStr = valueWithStr.String(), true
+		}
+	}
+	if valueIsStr {
+		matches, err := regexp.MatchString("^"+reStr+"$", valueStr)
+		if err != nil {
+			return false, "Can't compile regex: " + err.Error()
+		}
+		return matches, ""
+	}
+	return false, "Obtained value is not a string and has no .String()"
+}
+
+// -----------------------------------------------------------------------
+// Panics checker.
+
+type panicsChecker struct {
+	*CheckerInfo
+}
+
+// The Panics checker verifies that calling the provided zero-argument
+// function will cause a panic which is deep-equal to the provided value.
+//
+// For example:
+//
+//     c.Assert(func() { f(1, 2) }, Panics, &SomeErrorType{"BOOM"}).
+//
+//
+var Panics Checker = &panicsChecker{
+	&CheckerInfo{Name: "Panics", Params: []string{"function", "expected"}},
+}
+
+func (checker *panicsChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	f := reflect.ValueOf(params[0])
+	if f.Kind() != reflect.Func || f.Type().NumIn() != 0 {
+		return false, "Function must take zero arguments"
+	}
+	defer func() {
+		// If the function has not panicked, then don't do the check.
+		if error != "" {
+			return
+		}
+		params[0] = recover()
+		names[0] = "panic"
+		result = reflect.DeepEqual(params[0], params[1])
+	}()
+	f.Call(nil)
+	return false, "Function has not panicked"
+}
+
+type panicMatchesChecker struct {
+	*CheckerInfo
+}
+
+// The PanicMatches checker verifies that calling the provided zero-argument
+// function will cause a panic with an error value matching
+// the regular expression provided.
+//
+// For example:
+//
+//     c.Assert(func() { f(1, 2) }, PanicMatches, `open.*: no such file or directory`).
+//
+//
+var PanicMatches Checker = &panicMatchesChecker{
+	&CheckerInfo{Name: "PanicMatches", Params: []string{"function", "expected"}},
+}
+
+func (checker *panicMatchesChecker) Check(params []interface{}, names []string) (result bool, errmsg string) {
+	f := reflect.ValueOf(params[0])
+	if f.Kind() != reflect.Func || f.Type().NumIn() != 0 {
+		return false, "Function must take zero arguments"
+	}
+	defer func() {
+		// If the function has not panicked, then don't do the check.
+		if errmsg != "" {
+			return
+		}
+		obtained := recover()
+		names[0] = "panic"
+		if e, ok := obtained.(error); ok {
+			params[0] = e.Error()
+		} else if _, ok := obtained.(string); ok {
+			params[0] = obtained
+		} else {
+			errmsg = "Panic value is not a string or an error"
+			return
+		}
+		result, errmsg = matches(params[0], params[1])
+	}()
+	f.Call(nil)
+	return false, "Function has not panicked"
+}
+
+// -----------------------------------------------------------------------
+// FitsTypeOf checker.
+
+type fitsTypeChecker struct {
+	*CheckerInfo
+}
+
+// The FitsTypeOf checker verifies that the obtained value is
+// assignable to a variable with the same type as the provided
+// sample value.
+//
+// For example:
+//
+//     c.Assert(value, FitsTypeOf, int64(0))
+//     c.Assert(value, FitsTypeOf, os.Error(nil))
+//
+var FitsTypeOf Checker = &fitsTypeChecker{
+	&CheckerInfo{Name: "FitsTypeOf", Params: []string{"obtained", "sample"}},
+}
+
+func (checker *fitsTypeChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	obtained := reflect.ValueOf(params[0])
+	sample := reflect.ValueOf(params[1])
+	if !obtained.IsValid() {
+		return false, ""
+	}
+	if !sample.IsValid() {
+		return false, "Invalid sample value"
+	}
+	return obtained.Type().AssignableTo(sample.Type()), ""
+}
+
+// -----------------------------------------------------------------------
+// Implements checker.
+
+type implementsChecker struct {
+	*CheckerInfo
+}
+
+// The Implements checker verifies that the obtained value
+// implements the interface specified via a pointer to an interface
+// variable.
+//
+// For example:
+//
+//     var e os.Error
+//     c.Assert(err, Implements, &e)
+//
+var Implements Checker = &implementsChecker{
+	&CheckerInfo{Name: "Implements", Params: []string{"obtained", "ifaceptr"}},
+}
+
+func (checker *implementsChecker) Check(params []interface{}, names []string) (result bool, error string) {
+	obtained := reflect.ValueOf(params[0])
+	ifaceptr := reflect.ValueOf(params[1])
+	if !obtained.IsValid() {
+		return false, ""
+	}
+	if !ifaceptr.IsValid() || ifaceptr.Kind() != reflect.Ptr || ifaceptr.Elem().Kind() != reflect.Interface {
+		return false, "ifaceptr should be a pointer to an interface variable"
+	}
+	return obtained.Type().Implements(ifaceptr.Elem().Type()), ""
+}

=== added file 'internal/gopkg.in/check.v1/checkers_test.go'
--- internal/gopkg.in/check.v1/checkers_test.go	1970-01-01 00:00:00 +0000
+++ internal/gopkg.in/check.v1/checkers_test.go	2015-10-30 14:12:15 +0000
@@ -0,0 +1,272 @@
+package check_test
+
+import (
+	"errors"
+	"launchpad.net/crackly/internal/gopkg.in/check.v1"
+	"reflect"
+	"runtime"
+)
+
+type CheckersS struct{}
+
+var _ = check.Suite(&CheckersS{})
+
+func testInfo(c *check.C, checker check.Checker, name string, paramNames []string) {
+	info := checker.Info()
+	if info.Name != name {
+		c.Fatalf("Got name %s, expected %s", info.Name, name)
+	}
+	if !reflect.DeepEqual(info.Params, paramNames) {
+		c.Fatalf("Got param names %#v, expected %#v", info.Params, paramNames)
+	}
+}
+
+func testCheck(c *check.C, checker check.Checker, result bool, error string, params ...interface{}) ([]interface{}, []string) {
+	info := checker.Info()
+	if len(params) != len(info.Params) {
+		c.Fatalf("unexpected param count in test; expected %d got %d", len(info.Params), len(params))
+	}
+	names := append([]string{}, info.Params...)
+	result_, error_ := checker.Check(params, names)
+	if result_ != result || error_ != error {
+		c.Fatalf("%s.Check(%#v) returned (%#v, %#v) rather than (%#v, %#v)",
+			info.Name, params, result_, error_, result, error)
+	}
+	return params, names
+}
+
+func (s *CheckersS) TestComment(c *check.C) {
+	bug := check.Commentf("a %d bc", 42)
+	comment := bug.CheckCommentString()
+	if comment != "a 42 bc" {
+		c.Fatalf("Commentf returned %#v", comment)
+	}
+}
+
+func (s *CheckersS) TestIsNil(c *check.C) {
+	testInfo(c, check.IsNil, "IsNil", []string{"value"})
+
+	testCheck(c, check.IsNil, true, "", nil)
+	testCheck(c, check.IsNil, false, "", "a")
+
+	testCheck(c, check.IsNil, true, "", (chan int)(nil))
+	testCheck(c, check.IsNil, false, "", make(chan int))
+	testCheck(c, check.IsNil, true, "", (error)(nil))
+	testCheck(c, check.IsNil, false, "", errors.New(""))
+	testCheck(c, check.IsNil, true, "", ([]int)(nil))
+	testCheck(c, check.IsNil, false, "", make([]int, 1))
+	testCheck(c, check.IsNil, false, "", int(0))
+}
+
+func (s *CheckersS) TestNotNil(c *check.C) {
+	testInfo(c, check.NotNil, "NotNil", []string{"value"})
+
+	testCheck(c, check.NotNil, false, "", nil)
+	testCheck(c, check.NotNil, true, "", "a")
+
+	testCheck(c, check.NotNil, false, "", (chan int)(nil))
+	testCheck(c, check.NotNil, true, "", make(chan int))
+	testCheck(c, check.NotNil, false, "", (error)(nil))
+	testCheck(c, check.NotNil, true, "", errors.New(""))
+	testCheck(c, check.NotNil, false, "", ([]int)(nil))
+	testCheck(c, check.NotNil, true, "", make([]int, 1))
+}
+
+func (s *CheckersS) TestNot(c *check.C) {
+	testInfo(c, check.Not(check.IsNil), "Not(IsNil)", []string{"value"})
+
+	testCheck(c, check.Not(check.IsNil), false, "", nil)
+	testCheck(c, check.Not(check.IsNil), true, "", "a")
+}
+
+type simpleStruct struct {
+	i int
+}
+
+func (s *CheckersS) TestEquals(c *check.C) {
+	testInfo(c, check.Equals, "Equals", []string{"obtained", "expected"})
+
+	// The simplest.
+	testCheck(c, check.Equals, true, "", 42, 42)
+	testCheck(c, check.Equals, false, "", 42, 43)
+
+	// Different native types.
+	testCheck(c, check.Equals, false, "", int32(42), int64(42))
+
+	// With nil.
+	testCheck(c, check.Equals, false, "", 42, nil)
+
+	// Slices
+	testCheck(c, check.Equals, false, "runtime error: comparing uncomparable type []uint8", []byte{1, 2}, []byte{1, 2})
+
+	// Struct values
+	testCheck(c, check.Equals, true, "", simpleStruct{1}, simpleStruct{1})
+	testCheck(c, check.Equals, false, "", simpleStruct{1}, simpleStruct{2})
+
+	// Struct pointers
+	testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{1})
+	testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{2})
+}
+
+func (s *CheckersS) TestDeepEquals(c *check.C) {
+	testInfo(c, check.DeepEquals, "DeepEquals", []string{"obtained", "expected"})
+
+	// The simplest.