$ tree
.
├── bin
├── pkg
├── readme.txt
└── src
    ├── algorithms
    │   ├── bubblesort
    │   │   ├── bubblesort.go
    │   │   └── bubblesort_test.go
    │   └── qsort
    │       ├── qsort.go
    │       └── qsort_test.go
    └── sorter
        └── sorter.go

//bubblesort.go
package bubblesort

func BubbleSort(values []int) {
        flag := true

        for i := 0; i < len(values) - 1; i++ {
                flag = true

                for j := 0; j < len(values) - i - 1; j++ {
                        if values[j] > values[j + 1] {
                                values[j], values[j + 1] = values[j + 1], values[j]
                                flag = false
                        }
                        if flag == true {
                                break;
                        }
                }
        }
}

//bubble_test.ho
package bubblesort

import "testing"

func TestBubbleSort1(t * testing.T) {
        values := []int {5, 4, 3, 2, 1}
        BubbleSort(values)
        for i := 0; i < len(values) - 1; i++ {
                if values[i] > values[i + 1] {
                        t.Error("ubbleSort() faild. Got at ", values[i], values[i + 1])
                        break
                }
        }
}

func TestBubbleSort2(t * testing.T) {
        values := []int{5}
        BubbleSort(values)
        if(values[0] != 5) {
                t.Error("BubbleSort() faild. Got ", values, "Excepted 5")
        }
}

//qsort.go
package qsort

func quickSort(values []int, left, right int) {
        temp := values[left]
        p := left
        i, j := left, right

        for i <= j {
                for j >= p && values[j] >= temp {
                        j--
                }
                if j >= p {
                        values[p] = values[j]
                        p = j
                }
                if values[i] <= temp && i <= p {
                        i++
                }

                if i <= p {
                        values[p] = values[i]
                        p = i
                }
        }
        values[p] = temp
        if p - left > 1 {
                quickSort(values, left, p - 1)
        }
        if right - p > 1 {
                quickSort(values, p + 1, right)
        }
}

func QuickSort(values []int) {
        quickSort(values, 0 , len(values) - 1)
}

//qsort_test.go
package qsort

import "testing"

func TestQuickSort1(t * testing.T) {
        values := []int {5, 4, 3, 2, 1}
        QuickSort(values)
        var i int;
        var j int = len(values) - 1
        for i = 0; i < j; i++ {
                if values[i] > values[i + 1] {
                        t.Error("QuickSort() faild")
                        break;
                }
        }
}

func TestQuickSort2(t * testing.T) {
        values := []int {5}
        QuickSort(values)
        if values[0] != 5 {
                t.Error("QuickSort() faild. Got", values);
        }
}

package main

import "bufio"
import "flag"
import "fmt"
import "io"
import "os"
import "strconv"
import "time"

import "algorithms/bubblesort"
import "algorithms/qsort"

var infile              * string = flag.String("i", "unsorted.dat"      , "File contains values for sorting")
var outfile             * string = flag.String("o", "sorted.dat"        , "File to receive sorted values")
var algorithm   * string = flag.String("a", "qsort"                     , "Sort algorithm")

func readValues(infile string)(values []int, err error){
        file, err := os.Open(infile)
        if err != nil{
                fmt.Println("Failed to open the input file :", infile)
                return
        }
        defer file.Close()

        br := bufio.NewReader(file)

        values = make([]int, 0)

        for{
                line, isPrefix, err1 := br.ReadLine()

                if err1 != nil{
                        if err1 != io.EOF{
                                err = err1
                        }
                        break
                }
                if isPrefix {
                        fmt.Println("A too long line, seems unexpected.")
                        return
                }

                str := string(line)

                value, err1 := strconv.Atoi(str)

                if err1 != nil{
                        err = err1
                        return
                }

                values = append(values, value)
        }
        return
}

func writeValues(values []int, outfile string) error {
        file, err := os.Create(outfile)
        if err != nil {
                fmt.Println("Faild to create the outfile ", outfile)
                return err
        }

        defer file.Close()

        for _, value := range values {
                str := strconv.Itoa(value)
                file.WriteString(str + "\n")
        }

        return nil
}

func main(){
        flag.Parse()

        if infile != nil {
                fmt.Println("infile =", *infile, "outfile = ", *outfile, "algorithm = ", *algorithm)
        }

        values, err := readValues(*infile)

        if err == nil {
                t1 := time.Now()
                switch *algorithm {
                case "qsort" :
                        qsort.QuickSort(values)
                case "bubblesort" :
                        bubblesort.BubbleSort(values)
                        default :
                        fmt.Println("Sorting algorithm", * algorithm, "is either unknown or ensupported.")
                }
                t2 := time.Now()

                fmt.Println("The sorting process costs", t2.Sub(t1), "to complete.")
                writeValues(values, * outfile)
        }else {
                fmt.Println(err)
        }
}

[fengbo@sorter]$ pwd
/home/fengbo/sorter
[fengbo@sorter]$ export GOPATH="/home/fengbo/sorter"

$ go build algorithms/bubblesort
$ go build algorithms/qsort
$ go install algorithms/bubblesort
$ go install algorithms/qsort
$ go build sorter

$ tree
.
├── bin
├── pkg
│   └── linux_386
│       └── algorithms
│           ├── bubblesort.a
│           └── qsort.a
├── readme.txt
├── sorter
└── src
    ├── algorithms
    │   ├── bubblesort
    │   │   ├── bubblesort.go
    │   │   └── bubblesort_test.go
    │   └── qsort
    │       ├── qsort.go
    │       └── qsort_test.go
    └── sorter
        └── sorter.go

$ cat unsorted.dat
6
345
76564
5
66
443654
757
2365
565

$ ./sorter -i unsorted.dat -o sorted.dat -a qsort
infile = unsorted.dat outfile =  sorted.dat algorithm =  qsort
The sorting process costs 2.22us to complete.

$ ls
sorted.dat  sorter unsorted.dat
$ cat sorted.dat
5
6
66
345
565
757
2365
76564
443654