Cleanup

korthaj · korthaj · commit b9ba69341de1 · 2017-04-30T09:33:41.000+02:00
diff --git a/euler_test.go b/euler_test.go
@@ -4,154 +4,154 @@ import (
 	"testing"
 )
 
-func TestEuler(t *testing.T) {
+func TestEulerDirected(t *testing.T) {
 	g := New(0)
 	walk, ok := EulerDirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g = New(4)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Add(0, 0)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{0, 0}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Add(0, 1)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{0, 0, 1}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Add(2, 3)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, false); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Delete(2, 3)
 	g.Add(2, 1)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, false); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Delete(2, 1)
 	g.Add(2, 2)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, false); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 
 	g.Add(1, 2)
 	walk, ok = EulerDirected(g)
 	if mess, diff := diff(walk, []int{0, 0, 1, 2, 2}); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerDirected: %s", mess)
 	}
 }
 
 func TestEulerUndirected(t *testing.T) {
 	g := New(0)
 	walk, ok := EulerUndirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g = New(7)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(0, 0)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{0, 0}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(0, 1)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{0, 0, 1}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(2, 3)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, false); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(1, 2)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{0, 0, 1, 2, 3}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(2, 2)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{0, 0, 1, 2, 2, 3}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, true); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 
 	g.AddBoth(4, 5)
 	g.AddBoth(5, 6)
 	g.AddBoth(4, 6)
 	walk, ok = EulerUndirected(g)
 	if mess, diff := diff(walk, []int{}); diff {
-		t.Errorf("Euler undirected: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 	if mess, diff := diff(ok, false); diff {
-		t.Errorf("Euler: %s", mess)
+		t.Errorf("EulerUndirected: %s", mess)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -4,154 +4,154 @@ import (`
`4`	`4`	`"testing"`
`5`	`5`	`)`
`6`	`6`
`7`		`-func TestEuler(t *testing.T) {`
	`7`	`+func TestEulerDirected(t *testing.T) {`
`8`	`8`	`g := New(0)`
`9`	`9`	`walk, ok := EulerDirected(g)`
`10`	`10`	`if mess, diff := diff(walk, []int{}); diff {`
`11`		`- t.Errorf("Euler: %s", mess)`
	`11`	`+ t.Errorf("EulerDirected: %s", mess)`
`12`	`12`	`}`
`13`	`13`	`if mess, diff := diff(ok, true); diff {`
`14`		`- t.Errorf("Euler: %s", mess)`
	`14`	`+ t.Errorf("EulerDirected: %s", mess)`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`g = New(4)`
`18`	`18`	`walk, ok = EulerDirected(g)`
`19`	`19`	`if mess, diff := diff(walk, []int{}); diff {`
`20`		`- t.Errorf("Euler: %s", mess)`
	`20`	`+ t.Errorf("EulerDirected: %s", mess)`
`21`	`21`	`}`
`22`	`22`	`if mess, diff := diff(ok, true); diff {`
`23`		`- t.Errorf("Euler: %s", mess)`
	`23`	`+ t.Errorf("EulerDirected: %s", mess)`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`g.Add(0, 0)`
`27`	`27`	`walk, ok = EulerDirected(g)`
`28`	`28`	`if mess, diff := diff(walk, []int{0, 0}); diff {`
`29`		`- t.Errorf("Euler: %s", mess)`
	`29`	`+ t.Errorf("EulerDirected: %s", mess)`
`30`	`30`	`}`
`31`	`31`	`if mess, diff := diff(ok, true); diff {`
`32`		`- t.Errorf("Euler: %s", mess)`
	`32`	`+ t.Errorf("EulerDirected: %s", mess)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`g.Add(0, 1)`
`36`	`36`	`walk, ok = EulerDirected(g)`
`37`	`37`	`if mess, diff := diff(walk, []int{0, 0, 1}); diff {`
`38`		`- t.Errorf("Euler: %s", mess)`
	`38`	`+ t.Errorf("EulerDirected: %s", mess)`
`39`	`39`	`}`
`40`	`40`	`if mess, diff := diff(ok, true); diff {`
`41`		`- t.Errorf("Euler: %s", mess)`
	`41`	`+ t.Errorf("EulerDirected: %s", mess)`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`g.Add(2, 3)`
`45`	`45`	`walk, ok = EulerDirected(g)`
`46`	`46`	`if mess, diff := diff(walk, []int{}); diff {`
`47`		`- t.Errorf("Euler: %s", mess)`
	`47`	`+ t.Errorf("EulerDirected: %s", mess)`
`48`	`48`	`}`
`49`	`49`	`if mess, diff := diff(ok, false); diff {`
`50`		`- t.Errorf("Euler: %s", mess)`
	`50`	`+ t.Errorf("EulerDirected: %s", mess)`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`g.Delete(2, 3)`
`54`	`54`	`g.Add(2, 1)`
`55`	`55`	`walk, ok = EulerDirected(g)`
`56`	`56`	`if mess, diff := diff(walk, []int{}); diff {`
`57`		`- t.Errorf("Euler: %s", mess)`
	`57`	`+ t.Errorf("EulerDirected: %s", mess)`
`58`	`58`	`}`
`59`	`59`	`if mess, diff := diff(ok, false); diff {`
`60`		`- t.Errorf("Euler: %s", mess)`
	`60`	`+ t.Errorf("EulerDirected: %s", mess)`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`g.Delete(2, 1)`
`64`	`64`	`g.Add(2, 2)`
`65`	`65`	`walk, ok = EulerDirected(g)`
`66`	`66`	`if mess, diff := diff(walk, []int{}); diff {`
`67`		`- t.Errorf("Euler: %s", mess)`
	`67`	`+ t.Errorf("EulerDirected: %s", mess)`
`68`	`68`	`}`
`69`	`69`	`if mess, diff := diff(ok, false); diff {`
`70`		`- t.Errorf("Euler: %s", mess)`
	`70`	`+ t.Errorf("EulerDirected: %s", mess)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`g.Add(1, 2)`
`74`	`74`	`walk, ok = EulerDirected(g)`
`75`	`75`	`if mess, diff := diff(walk, []int{0, 0, 1, 2, 2}); diff {`
`76`		`- t.Errorf("Euler: %s", mess)`
	`76`	`+ t.Errorf("EulerDirected: %s", mess)`
`77`	`77`	`}`
`78`	`78`	`if mess, diff := diff(ok, true); diff {`
`79`		`- t.Errorf("Euler: %s", mess)`
	`79`	`+ t.Errorf("EulerDirected: %s", mess)`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`func TestEulerUndirected(t *testing.T) {`
`84`	`84`	`g := New(0)`
`85`	`85`	`walk, ok := EulerUndirected(g)`
`86`	`86`	`if mess, diff := diff(walk, []int{}); diff {`
`87`		`- t.Errorf("Euler undirected: %s", mess)`
	`87`	`+ t.Errorf("EulerUndirected: %s", mess)`
`88`	`88`	`}`
`89`	`89`	`if mess, diff := diff(ok, true); diff {`
`90`		`- t.Errorf("Euler: %s", mess)`
	`90`	`+ t.Errorf("EulerUndirected: %s", mess)`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`g = New(7)`
`94`	`94`	`walk, ok = EulerUndirected(g)`
`95`	`95`	`if mess, diff := diff(walk, []int{}); diff {`
`96`		`- t.Errorf("Euler undirected: %s", mess)`
	`96`	`+ t.Errorf("EulerUndirected: %s", mess)`
`97`	`97`	`}`
`98`	`98`	`if mess, diff := diff(ok, true); diff {`
`99`		`- t.Errorf("Euler: %s", mess)`
	`99`	`+ t.Errorf("EulerUndirected: %s", mess)`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`g.AddBoth(0, 0)`
`103`	`103`	`walk, ok = EulerUndirected(g)`
`104`	`104`	`if mess, diff := diff(walk, []int{0, 0}); diff {`
`105`		`- t.Errorf("Euler undirected: %s", mess)`
	`105`	`+ t.Errorf("EulerUndirected: %s", mess)`
`106`	`106`	`}`
`107`	`107`	`if mess, diff := diff(ok, true); diff {`
`108`		`- t.Errorf("Euler: %s", mess)`
	`108`	`+ t.Errorf("EulerUndirected: %s", mess)`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`g.AddBoth(0, 1)`
`112`	`112`	`walk, ok = EulerUndirected(g)`
`113`	`113`	`if mess, diff := diff(walk, []int{0, 0, 1}); diff {`
`114`		`- t.Errorf("Euler undirected: %s", mess)`
	`114`	`+ t.Errorf("EulerUndirected: %s", mess)`
`115`	`115`	`}`
`116`	`116`	`if mess, diff := diff(ok, true); diff {`
`117`		`- t.Errorf("Euler: %s", mess)`
	`117`	`+ t.Errorf("EulerUndirected: %s", mess)`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`g.AddBoth(2, 3)`
`121`	`121`	`walk, ok = EulerUndirected(g)`
`122`	`122`	`if mess, diff := diff(walk, []int{}); diff {`
`123`		`- t.Errorf("Euler undirected: %s", mess)`
	`123`	`+ t.Errorf("EulerUndirected: %s", mess)`
`124`	`124`	`}`
`125`	`125`	`if mess, diff := diff(ok, false); diff {`
`126`		`- t.Errorf("Euler: %s", mess)`
	`126`	`+ t.Errorf("EulerUndirected: %s", mess)`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`g.AddBoth(1, 2)`
`130`	`130`	`walk, ok = EulerUndirected(g)`
`131`	`131`	`if mess, diff := diff(walk, []int{0, 0, 1, 2, 3}); diff {`
`132`		`- t.Errorf("Euler undirected: %s", mess)`
	`132`	`+ t.Errorf("EulerUndirected: %s", mess)`
`133`	`133`	`}`
`134`	`134`	`if mess, diff := diff(ok, true); diff {`
`135`		`- t.Errorf("Euler: %s", mess)`
	`135`	`+ t.Errorf("EulerUndirected: %s", mess)`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`g.AddBoth(2, 2)`
`139`	`139`	`walk, ok = EulerUndirected(g)`
`140`	`140`	`if mess, diff := diff(walk, []int{0, 0, 1, 2, 2, 3}); diff {`
`141`		`- t.Errorf("Euler undirected: %s", mess)`
	`141`	`+ t.Errorf("EulerUndirected: %s", mess)`
`142`	`142`	`}`
`143`	`143`	`if mess, diff := diff(ok, true); diff {`
`144`		`- t.Errorf("Euler: %s", mess)`
	`144`	`+ t.Errorf("EulerUndirected: %s", mess)`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`g.AddBoth(4, 5)`
`148`	`148`	`g.AddBoth(5, 6)`
`149`	`149`	`g.AddBoth(4, 6)`
`150`	`150`	`walk, ok = EulerUndirected(g)`
`151`	`151`	`if mess, diff := diff(walk, []int{}); diff {`
`152`		`- t.Errorf("Euler undirected: %s", mess)`
	`152`	`+ t.Errorf("EulerUndirected: %s", mess)`
`153`	`153`	`}`
`154`	`154`	`if mess, diff := diff(ok, false); diff {`
`155`		`- t.Errorf("Euler: %s", mess)`
	`155`	`+ t.Errorf("EulerUndirected: %s", mess)`
`156`	`156`	`}`
`157`	`157`	`}`