Initial import

Author: jdeppe-pivotal

.envrc

@@ -0,0 +1 @@
+export GOPATH=$PWD

.gitignore

@@ -0,0 +1,3 @@
+**/vendor/**/*
+pkg/
+.idea/

src/progress/core/core_suite_test.go

@@ -0,0 +1,13 @@
+package core_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestCore(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Core Suite")
+}

src/progress/core/hangs.go

@@ -0,0 +1,51 @@
+package core
+
+import (
+	"strings"
+	"fmt"
+)
+
+type ProgressHangs struct {
+	tests map[string]string
+	startTime *string
+	endTime *string
+}
+
+func NewProgressHangs() *ProgressHangs {
+	ph := &ProgressHangs{}
+	ph.tests = make(map[string]string)
+	return ph
+}
+
+func (this *ProgressHangs) ProcessLine(line string) {
+	parts := strings.Split(line, " ")
+	if len(parts) < 7 {
+		return
+	}
+
+	timeStamp := fmt.Sprintf("%s %s %s", parts[0], parts[1], parts[2])
+	this.endTime = &timeStamp
+
+	testName := fmt.Sprintf("%s %s", parts[5], parts[6])
+	state := parts[3]
+
+	if state == "Starting" {
+		this.tests[testName] = timeStamp
+
+		if this.startTime == nil {
+			this.startTime = &timeStamp
+		}
+	} else if state == "Completed" {
+		delete(this.tests, testName)
+	}
+}
+
+func (this *ProgressHangs) Results() {
+	fmt.Printf("Started @ %s\n", *this.startTime)
+	for k, v := range this.tests {
+		fmt.Printf("%s  %s\n", v, k)
+	}
+	fmt.Printf("Ended @ %s\n", *this.endTime)
+
+}
+

src/progress/core/progress.go

@@ -0,0 +1,6 @@
+package core
+
+type Progress interface {
+	ProcessLine(string)
+	Results()
+}

src/progress/core/timings.go

@@ -0,0 +1,90 @@
+package core
+
+import (
+	"strings"
+	"fmt"
+	"time"
+	"log"
+	"sort"
+)
+
+type oneTest struct {
+	TestClass string
+	StartTime time.Time
+	EndTime   time.Time
+	Duration  time.Duration
+	TestCount int
+}
+
+type ProgressTimings []*oneTest
+
+func NewProgressTimings() *ProgressTimings {
+	return &ProgressTimings{}
+}
+
+// 2017-11-19 15:31:34.493 +0000 Starting test org....
+func (this *ProgressTimings) ProcessLine(line string) {
+	parts := strings.Split(line, " ")
+	if len(parts) < 7 {
+		return
+	}
+
+	timeStampRaw := fmt.Sprintf("%s %s %s", parts[0], parts[1], parts[2])
+
+	timeStamp, err := time.Parse("2006-01-02 15:04:05.000 -0700", timeStampRaw)
+	if err != nil {
+		log.Panicf("Unable to process timestamp %s", timeStampRaw)
+	}
+
+	testClass := parts[5]
+	state := parts[3]
+
+	entry, found := this.get(testClass)
+	if state == "Starting" {
+		if found {
+			entry.StartTime = timeStamp
+			entry.TestCount += 1
+		} else {
+			*this = append(*this, &oneTest{
+				TestClass: testClass,
+				StartTime: timeStamp,
+				TestCount: 1,
+			})
+		}
+	} else if state == "Completed" {
+		if !found {
+			log.Panicf("Unable to find entry for %s", testClass)
+		}
+		entry.EndTime = timeStamp
+		entry.Duration += entry.EndTime.Sub(entry.StartTime)
+	}
+}
+
+func (this *ProgressTimings) Results() {
+	sort.Sort(this)
+	for _, v := range *this {
+		fmt.Printf("%9.3f %3d  %s\n", v.Duration.Seconds(), v.TestCount, v.TestClass)
+	}
+}
+
+func (this *ProgressTimings) Len() int {
+	return len(*this)
+}
+
+func (this *ProgressTimings) Swap(i, j int) {
+	(*this)[i], (*this)[j] = (*this)[j], (*this)[i]
+}
+
+func (this *ProgressTimings) Less(i, j int) bool {
+	return (*this)[i].Duration.Nanoseconds() > (*this)[j].Duration.Nanoseconds()
+}
+
+func (this *ProgressTimings) get(key string) (*oneTest, bool) {
+	for _, v := range *this {
+		if v.TestClass == key {
+			return v, true
+		}
+	}
+
+	return nil, false;
+}

src/progress/core/timings_test.go

@@ -0,0 +1,67 @@
+package core_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"progress/core"
+	"time"
+	"sort"
+)
+
+var _ = Describe("", func() {
+	It("", func() {
+		p := core.NewProgressTimings()
+
+		p.ProcessLine( "2017-11-19 15:31:34.493 +0000 Starting test TestClass testMethod")
+
+		Expect(len(*p)).To(Equal(1))
+
+		Expect((*p)[0].StartTime).To(BeTemporally("==", time.Date(2017, 11, 19, 15, 31, 34, int((time.Millisecond *493).Nanoseconds()), time.UTC)))
+
+		p.ProcessLine("2017-11-19 15:31:35.493 +0000 Completed test TestClass testMethod")
+
+		Expect(len(*p)).To(Equal(1))
+		Expect((*p)[0].Duration).To(Equal(time.Second * 1))
+
+		p.ProcessLine("2017-11-19 15:31:36.493 +0000 Starting test TestClass testMethod")
+		p.ProcessLine("2017-11-19 15:31:37.493 +0000 Completed test TestClass testMethod")
+
+		Expect(len(*p)).To(Equal(1))
+		Expect((*p)[0].Duration).To(Equal(time.Second * 2))
+	})
+
+	It("Sorts", func() {
+		p := core.NewProgressTimings()
+
+		p.ProcessLine("2017-11-19 15:31:34.493 +0000 Starting test TestClass1 testMethod")
+		p.ProcessLine("2017-11-19 15:31:35.493 +0000 Completed test TestClass1 testMethod")
+		p.ProcessLine("2017-11-19 15:31:35.493 +0000 Starting test TestClass2 testMethod")
+		p.ProcessLine("2017-11-19 15:31:37.493 +0000 Completed test TestClass2 testMethod")
+
+		Expect(len(*p)).To(Equal(2))
+
+		sort.Sort(p)
+
+		Expect((*p)[0].TestClass).To(Equal("TestClass2"))
+		Expect((*p)[0].Duration).To(Equal(time.Second * 2))
+		Expect((*p)[0].TestCount).To(Equal(1))
+		Expect((*p)[1].TestClass).To(Equal("TestClass1"))
+		Expect((*p)[1].Duration).To(Equal(time.Second * 1))
+		Expect((*p)[1].TestCount).To(Equal(1))
+	})
+
+	It("Accumulate", func() {
+		p := core.NewProgressTimings()
+
+		p.ProcessLine("2017-11-19 15:31:34.000 +0000 Starting test TestClass1 testMethod1")
+		p.ProcessLine("2017-11-19 15:31:35.000 +0000 Completed test TestClass1 testMethod1")
+		p.ProcessLine("2017-11-19 15:31:35.000 +0000 Starting test TestClass1 testMethod2")
+		p.ProcessLine("2017-11-19 15:31:36.100 +0000 Completed test TestClass1 testMethod2")
+		p.ProcessLine("2017-11-19 15:31:36.100 +0000 Starting test TestClass1 testMethod3")
+		p.ProcessLine("2017-11-19 15:31:37.200 +0000 Completed test TestClass1 testMethod3")
+
+		Expect(len(*p)).To(Equal(1))
+		Expect((*p)[0].Duration.Seconds()).To(Equal(3.2))
+		Expect((*p)[0].TestCount).To(Equal(3))
+	})
+})

src/progress/core/uniques.go

@@ -0,0 +1,45 @@
+package core
+
+import (
+	"strings"
+	"fmt"
+)
+
+type ProgressUniques struct {
+	tests []string
+}
+
+func NewProgressUniques() *ProgressUniques {
+	t := make([]string, 0)
+	return &ProgressUniques{tests: t}
+}
+
+func (this *ProgressUniques) ProcessLine(line string) {
+	parts := strings.Split(line, " ")
+	if len(parts) < 7 {
+		return
+	}
+
+	testName := parts[5]
+	state := parts[3]
+
+	if state == "Starting" && ! entryExists(this.tests, testName) {
+		this.tests = append(this.tests, testName)
+	}
+}
+
+func (this *ProgressUniques) Results() {
+	for _, v := range this.tests {
+		fmt.Println(v)
+	}
+}
+
+func entryExists(list []string, entry string) bool {
+	for _, v := range list {
+		if v == entry {
+			return true
+		}
+	}
+	return false
+}
+

src/progress/main.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"bufio"
+	"io"
+	"strings"
+	"progress/core"
+)
+
+func main() {
+	flag.Parse()
+
+	var p core.Progress
+	switch flag.Arg(0) {
+	case "times":
+		p = core.NewProgressTimings()
+	case "unique":
+		p = core.NewProgressUniques()
+	case "hang":
+		p = core.NewProgressHangs()
+	}
+
+	progressFile, err := os.Open(flag.Arg(1))
+	if err != nil {
+		panic(err)
+	}
+
+	defer progressFile.Close()
+
+	reader := bufio.NewReader(progressFile)
+
+	var line string
+	for {
+		line, err = reader.ReadString('\n')
+		line = strings.TrimSpace(line)
+
+		p.ProcessLine(line)
+
+		if err != nil {
+			break
+		}
+	}
+
+	if err != io.EOF {
+		panic(err)
+	}
+
+	p.Results()
+}
+

src/progress/vendor/vendor.json

@@ -0,0 +1,19 @@
+{
+	"comment": "",
+	"ignore": "test",
+	"package": [
+		{
+			"checksumSHA1": "BsmyRqx3D6A0RmWl/7K8iWe8PMA=",
+			"path": "github.com/onsi/ginkgo",
+			"revision": "652e15c9a27e1cec563e065568014f29eecf6bd9",
+			"revisionTime": "2017-10-30T19:16:46Z"
+		},
+		{
+			"checksumSHA1": "K/+zcF9uhF8ZCTTUGmeBhPRchGU=",
+			"path": "github.com/onsi/gomega",
+			"revision": "1eecca0ba8e6f5ea5a431ce21d3aee2af0b4c90b",
+			"revisionTime": "2017-11-05T03:16:54Z"
+		}
+	],
+	"rootPath": "progress"
+}