diff --git a/afrouter/afrouter/affinity-router.go b/afrouter/afrouter/affinity-router.go
index 443a55e..30d1982 100644
--- a/afrouter/afrouter/affinity-router.go
+++ b/afrouter/afrouter/affinity-router.go
@@ -20,6 +20,7 @@
 import (
 	"fmt"
 	"errors"
+	"regexp"
 	"strconv"
 	"io/ioutil"
 	"google.golang.org/grpc"
@@ -28,6 +29,11 @@
 	pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )
 
+const (
+	PKG_MTHD_PKG int = 1
+	PKG_MTHD_MTHD int = 2
+)
+
 type AffinityRouter struct {
 	name string
 	routerType int // TODO: This is probably not needed 
@@ -45,6 +51,7 @@
 func newAffinityRouter(rconf *RouterConfig, config *RouteConfig) (Router,error) {
 	var err error = nil
 	var rtrn_err bool = false
+	var pkg_re *regexp.Regexp = regexp.MustCompile(`^(\.[^.]+\.)(.+)$`)
 	// Validate the configuration
 
 	// A name must exist
@@ -150,8 +157,14 @@
 						// Determine if this is a method we're supposed to be processing.
 						if needMethod(*m.Name, config) == true {
 							log.Debugf("Enabling method '%s'",*m.Name)
+							pkg_methd := pkg_re.FindStringSubmatch(*m.InputType)
+							if pkg_methd == nil {
+								log.Errorf("Regular expression didn't match input type '%s'",*m.InputType)
+								rtrn_err = true
+							}
 							// The input type has the package name prepended to it. Remove it.
-							in := (*m.InputType)[len(rconf.ProtoPackage)+2:]
+							//in := (*m.InputType)[len(rconf.ProtoPackage)+2:]
+							in := pkg_methd[PKG_MTHD_MTHD]
 							dr.methodMap[*m.Name], ok = msgs[key{in, config.RouteField}]
 							if ok == false {
 								log.Errorf("Method '%s' has no field named '%s' in it's parameter message '%s'",
@@ -243,7 +256,7 @@
 func (r AffinityRouter) decodeProtoField(payload []byte, fieldId byte) (string, error) {
 	idx :=0
 	b := proto.NewBuffer([]byte{})
-	b.DebugPrint("The Buffer", payload)
+	//b.DebugPrint("The Buffer", payload)
 	for { // Find the route selector field
 		log.Debugf("Decoding afinity value attributeNumber: %d from %v at index %d", fieldId, payload, idx)
 		log.Debugf("Attempting match with payload: %d, methodTable: %d", payload[idx], fieldId)
@@ -305,6 +318,7 @@
 			}
 			// Not a south affinity binding method, proceed with north affinity binding.
 			if selector,err := r.decodeProtoField(sl.payload, r.methodMap[sl.mthdSlice[REQ_METHOD]]); err == nil {
+				log.Debugf("Establishing affinity for selector: %s", selector)
 				if rtrn,ok := r.affinity[selector]; ok {
 					return rtrn
 				} else {
diff --git a/afrouter/afrouter/api.go b/afrouter/afrouter/api.go
index 7f7ba54..5766e8d 100644
--- a/afrouter/afrouter/api.go
+++ b/afrouter/afrouter/api.go
@@ -20,8 +20,9 @@
 import (
 	"net"
 	"fmt"
-	"strconv"
 	"errors"
+	"runtime"
+	"strconv"
 	"google.golang.org/grpc"
 	"golang.org/x/net/context"
 	"github.com/opencord/voltha-go/common/log"
@@ -217,6 +218,10 @@
 	return &pb.Result{Success:true,Error:""},nil
 }
 
+func (aa ArouterApi) GetGoroutineCount(ctx context.Context, in *pb.Empty) (*pb.Count, error) {
+	return &pb.Count{Count:uint32(runtime.NumGoroutine())}, nil
+}
+
 func (aa *ArouterApi) serve() {
 	// Start a serving thread
 	go func() {
diff --git a/afrouter/afrouter/method-router.go b/afrouter/afrouter/method-router.go
index e4824da..379bf11 100644
--- a/afrouter/afrouter/method-router.go
+++ b/afrouter/afrouter/method-router.go
@@ -36,10 +36,12 @@
 func newMethodRouter(config *RouterConfig) (Router, error) {
 	mr := MethodRouter{name:config.Name,service:config.ProtoService,mthdRt:make(map[string]map[string]Router)}
 	mr.mthdRt[NoMeta] = make(map[string]Router) // For routes not needing metadata (all expcept binding at this time)
+	log.Debugf("Processing MethodRouter config %v", *config)
 	if len(config.Routes) == 0 {
 		return nil, errors.New(fmt.Sprintf("Router %s must have at least one route", config.Name))
 	}
 	for _,rtv := range config.Routes {
+		//log.Debugf("Processing route: %v",rtv)
 		var idx1 string
 		r,err := newSubRouter(config, &rtv)
 		if err != nil {
@@ -61,24 +63,24 @@
 				return r, nil
 			} else {
 				log.Debugf("Setting router '%s' for single method '%s'",r.Name(),rtv.Methods[0])
-				if _,ok := mr.mthdRt[""][rtv.Methods[0]]; ok == false {
+				if _,ok := mr.mthdRt[idx1][rtv.Methods[0]]; ok == false {
 					mr.mthdRt[idx1][rtv.Methods[0]] = r
 				} else {
 					err := errors.New(fmt.Sprintf("Attempt to define method %s for 2 routes: %s & %s", rtv.Methods[0],
 						r.Name(), mr.mthdRt[idx1][rtv.Methods[0]].Name()))
-					log.Debug(err)
+					log.Error(err)
 					return mr, err
 				}
 			}
 		default:
 			for _,m := range rtv.Methods {
-				log.Debugf("Setting router '%s' for method '%s'",r.Name(),m)
+				log.Debugf("Processing Method %s", m)
 				if _,ok := mr.mthdRt[idx1][m]; ok == false {
+					log.Debugf("Setting router '%s' for method '%s'",r.Name(),m)
 					mr.mthdRt[idx1][m] = r
 				} else {
-					err := errors.New(fmt.Sprintf("Attempt to define method %s for 2 routes: %s & %s", rtv.Methods[0],
-						r.Name(), mr.mthdRt[idx1][m].Name()))
-					log.Debug(err)
+					err := errors.New(fmt.Sprintf("Attempt to define method %s for 2 routes: %s & %s", m, r.Name(), mr.mthdRt[idx1][m].Name()))
+					log.Error(err)
 					return mr, err
 				}
 			}
diff --git a/docker/Dockerfile.arouterTest b/docker/Dockerfile.arouterTest
index 5fe1dc2..302c7b6 100644
--- a/docker/Dockerfile.arouterTest
+++ b/docker/Dockerfile.arouterTest
@@ -27,6 +27,7 @@
 # Compile protobuf files
 # Repeat here even if it's done in the base
 RUN sh /src/protos/build_protos.sh /src/protos
+#RUN find / -name "*.pb.go" -print
 
 #ADD /src/protos/voltha.pb test/afrouter/suites
 # Build rw_core
@@ -35,7 +36,7 @@
 RUN cp /src/protos/voltha.pb tests/afrouter/suites
 RUN cd tests/afrouter && go build -o /src/afrouterTest
 RUN mkdir /src/tests
-RUN cd tests/afrouter/suites && /src/afrouterTest -config main.json
+RUN cd tests/afrouter/suites && /src/afrouterTest -config main.json -logLevel 1
 RUN mkdir /src/temp
 RUN cp -r tests/afrouter/tests /src/temp
 #RUN cd tests/afrouter/tester && go build -o /src/tests
@@ -55,9 +56,10 @@
 COPY --from=build-env /src/arouter.json /app/
 COPY --from=build-env /src/arouter_test.json /app/
 COPY --from=build-env /src/protos/voltha.pb /app/
-COPY --from=build-env /src/suites /app
+COPY --from=build-env /src/suites/ /app/suites/
 COPY --from=build-env /src/tests /app
 COPY --from=build-env /src/temp/ /app/src/
+COPY --from=build-env /go/src/github.com/opencord/voltha-go/protos/ /app/protos/
 WORKDIR /app
 
 #CMD cd /app && ./arouter -config config/arouter.voltha2.json
diff --git a/protos/afrouter.proto b/protos/afrouter.proto
index 903e5cc..7702841 100644
--- a/protos/afrouter.proto
+++ b/protos/afrouter.proto
@@ -7,13 +7,22 @@
 package afrouter;
 
 service Configuration {
-    rpc SetConnection (Conn) returns (Result) {}
+	rpc SetConnection (Conn) returns (Result) {}
 	rpc SetAffinity(Affinity) returns (Result) {}
+	rpc GetGoroutineCount(Empty) returns (Count) {}
+}
+
+message Empty {
+}
+
+message Count {
+	uint32 count = 1;
 }
 
 message Result {
 	bool success = 1;
 	string error = 2;
+	string info = 3;
 }
 
 message Conn {
diff --git a/tests/afrouter/arouter_test.json b/tests/afrouter/arouter_test.json
index 0829737..d58f26d 100644
--- a/tests/afrouter/arouter_test.json
+++ b/tests/afrouter/arouter_test.json
@@ -30,9 +30,10 @@
 					"backend_cluster":"vcore",
 					"_COMMENT":"Methods are naturally southbound affinity binding unless otherwise specified below",
 					"methods":[ "CreateDevice",
-								"GetCoreInstance",
 								"EnableLogicalDevicePort",
 								"DisableLogicalDevicePort",
+								"UpdateLogicalDeviceFlowTable",
+								"UpdateLogicalDeviceFlowGroupTable",
 								"EnableDevice",
 								"DisableDevice",
 								"RebootDevice",
@@ -59,6 +60,15 @@
 					]
 				},
 				{
+					"name":"control",
+		   			"type":"round_robin",
+		   			"association":"round_robin",
+					"backend_cluster":"vcore",
+					"methods":[ 
+								"UpdateLogLevel"
+					]
+				},
+				{
 					"name":"read_only",
 		   			"type":"round_robin",
 		   			"association":"round_robin",
@@ -79,8 +89,17 @@
 								"GetDeviceGroup",
 								"GetLogicalDevice",
 								"GetAlarmFilter",
+								"ListLogicalDevices",
 								"ListLogicalDevicePorts",
-								"GetLogicalDevicePort"
+								"GetLogicalDevicePort",
+								"GetVoltha",
+								"ListCoreInstances",
+								"ListAdapters",
+								"ListDeviceIds",
+								"ListDeviceTypes",
+								"ListDeviceGroups",
+								"ListAlarmFilters",
+								"GetCoreInstance"
 					]
 				},
 				{
diff --git a/tests/afrouter/suites/main.json b/tests/afrouter/suites/main.json
index a1bc09c..594bc8a 100644
--- a/tests/afrouter/suites/main.json
+++ b/tests/afrouter/suites/main.json
@@ -2,6 +2,7 @@
 "__COMMENT":"Top level test driver file",
 "suites": [
 	"test1",
-	"test2"
-]
+	"test2",
+	"test3"
+	]
 }
diff --git a/tests/afrouter/suites/test1.json b/tests/afrouter/suites/test1.json
index 9e749ac..77cc0ec 100644
--- a/tests/afrouter/suites/test1.json
+++ b/tests/afrouter/suites/test1.json
@@ -1,16 +1,26 @@
 {
 	"environment":{
-		"cmdLine":"afrouter -config arouter_test.json",
+		"cmdLine":"afrouter -logLevel 1 -config arouter_test.json",
 		"protoFiles": [
 			{
 				"importPath":"github.com/opencord/voltha-go/protos/",
 				"service":"VolthaService",
 				"package":"voltha"
+			},
+			{
+				"importPath":"github.com/opencord/voltha-go/protos/",
+				"service":"Configuration",
+				"package":"afrouter"
+			}
+		],
+		"Junk": [
+			{
+				"importPath":"github.com/opencord/voltha-go/protos/",
+				"service":"Configuration",
+				"package":"afrouter"
 			}
 		],
 		"imports": [
-			 "github.com/golang/protobuf/ptypes/empty",
-			 "github.com/opencord/voltha-go/protos/openflow_13"
 		],
 		"protoDesc":"voltha.pb",
 		"protoSubst": [
@@ -19,13 +29,28 @@
 				"to":"empty.Empty"
 			}
 		],
-		"clients": [
-			{
-				"name":"client",
-				"port":"5000"
-			}
-		],
-		"servers": [
+		"clients": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
+				{
+					"name":"client",
+					"port":"5000"
+				},
+				{
+					"name":"stats",
+					"port":"55554"
+				}
+			]
+		},
+		"servers": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
 			{
 				"name":"core11",
 				"port":"5011"
@@ -49,8 +74,21 @@
 			{
 				"name":"core32",
 				"port":"5032"
+			},
+			{
+				"name":"roCore1",
+				"port":"5001"
+			},
+			{
+				"name":"roCore2",
+				"port":"5002"
+			},
+			{
+				"name":"roCore3",
+				"port":"5003"
 			}
-		]
+			]
+		}
 	},
 	"tests":[
 		{
@@ -150,6 +188,19 @@
 					]
 				}
 			]
+		},
+		{
+			"name":"Get goroutine count",
+			"infoOnly":true,
+			"send": {
+				"client":"stats",
+				"method":"GetGoroutineCount",
+				"param":"{}",
+				"meta": [ ],
+				"expect":"{Count:39}",
+				"expectMeta": [ ]
+			},
+			"servers": [ ]
 		}
 	]
 }
diff --git a/tests/afrouter/suites/test2.go b/tests/afrouter/suites/test2.go
index fc0332e..80e3af3 100644
--- a/tests/afrouter/suites/test2.go
+++ b/tests/afrouter/suites/test2.go
@@ -33,28 +33,37 @@
 	//pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )
 
+type suite struct {
+	CrTests []test
+	GetTests[]test
+}
+
 type test struct {
 	Core int
+	SerNo int
 }
 
+const SUITE_LEN = 55000
+//const SUITE_LEN = 100
+
 func main() {
 
-	var ary []test
+	var ary suite
 
 	// Setup logging
 	if _, err := log.SetDefaultLogger(log.JSON, 0, nil); err != nil {
 		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
 	}
 
-	for i :=0; i<10000; i++ {
-		
-		ary = append(ary,test{Core:(i%3)+1})
+	for i :=0; i<SUITE_LEN; i++ {
+
+		ary.CrTests = append(ary.CrTests,test{Core:(i%3)+1, SerNo:i})
+		ary.GetTests = append(ary.GetTests,test{Core:(i%3)+1, SerNo:i+SUITE_LEN})
 	}
 
 	// Load the template to execute
 	t := template.Must(template.New("").ParseFiles("./test2.tmpl.json"))
 	if f,err := os.Create("test2.json"); err == nil {
-		_=f
 		defer f.Close()
 		if err := t.ExecuteTemplate(f, "test2.tmpl.json", ary); err != nil {
 			log.Errorf("Unable to execute template for test2.tmpl.json: %v", err)
diff --git a/tests/afrouter/suites/test2.tmpl.json b/tests/afrouter/suites/test2.tmpl.json
index fc8ef1c..c8d040e 100644
--- a/tests/afrouter/suites/test2.tmpl.json
+++ b/tests/afrouter/suites/test2.tmpl.json
@@ -1,16 +1,20 @@
 {
 	"environment":{
-		"cmdLine":"afrouter -config arouter_test.json -grpclog",
+		"cmdLine":"afrouter -config arouter_test.json -logLevel 1",
 		"protoFiles": [
 			{
 				"importPath":"github.com/opencord/voltha-go/protos/",
 				"service":"VolthaService",
 				"package":"voltha"
+			},
+			{
+				"importPath":"github.com/opencord/voltha-go/protos/",
+				"service":"Configuration",
+				"package":"afrouter"
 			}
 		],
 		"imports": [
-			 "github.com/golang/protobuf/ptypes/empty",
-			 "github.com/opencord/voltha-go/protos/openflow_13"
+			 "github.com/golang/protobuf/ptypes/empty"
 		],
 		"protoDesc":"voltha.pb",
 		"protoSubst": [
@@ -19,13 +23,28 @@
 				"to":"empty.Empty"
 			}
 		],
-		"clients": [
-			{
-				"name":"client",
-				"port":"5000"
-			}
-		],
-		"servers": [
+		"clients": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
+				{
+					"name":"client",
+					"port":"5000"
+				},
+				{
+					"name":"stats",
+					"port":"55554"
+				}
+			]
+		},
+		"servers": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
 			{
 				"name":"core11",
 				"port":"5011"
@@ -50,10 +69,11 @@
 				"name":"core32",
 				"port":"5032"
 			}
-		]
+			]
+		}
 	},
 	"tests":[
-		{{range $k,$v := .}}
+		{{range $k,$v := .CrTests}}
 		{
 			"name":"Test CreateDevice",
 			"send": {
@@ -69,7 +89,7 @@
 					"meta": [
 						{
 							"key":"voltha_serial_number",
-							"value":"{{$k}}"
+							"value":"{{$v.SerNo}}"
 						}
 					]
 				},
@@ -78,7 +98,41 @@
 					"meta": [
 						{
 							"key":"voltha_serial_number",
-							"value":"{{$k}}"
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				}
+			]
+		},
+		{{end}}
+		{{range $k,$v := .GetTests}}
+		{
+			"name":"Test EnableDevice",
+			"send": {
+				"client":"client",
+				"_method":"GetDevice",
+				"method":"EnableDevice",
+				"param":"{Id:\"abcd1234{{$k}}\"}",
+				"expect":"{}",
+				"_expect":"{Id:\"abcd1234{{$k}}\",Type:\"simulated_olt\"}",
+				"_meta":""
+			},
+			"servers": [
+				{
+					"name":"core{{$v.Core}}1",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				},
+				{
+					"name":"core{{$v.Core}}2",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
 						}
 					]
 				}
@@ -100,7 +154,7 @@
 					"meta": [
 						{
 							"key":"voltha_serial_number",
-							"value":"10000"
+							"value":"110000"
 						}
 					]
 				},
@@ -109,7 +163,7 @@
 					"meta": [
 						{
 							"key":"voltha_serial_number",
-							"value":"10000"
+							"value":"110000"
 						}
 					]
 				}
@@ -141,7 +195,7 @@
 					"meta": [
 						{
 							"key":"voltha_serial_number",
-							"value":"10001"
+							"value":"110001"
 						},
 						{
 							"key":"voltha_backend_name",
@@ -150,6 +204,19 @@
 					]
 				}
 			]
+		},
+		{
+			"_COMMENT":"If this test case fails, there could be a goroutine leak",
+			"name":"Get goroutine count",
+			"send": {
+				"client":"stats",
+				"method":"GetGoroutineCount",
+				"param":"{}",
+				"meta": [ ],
+				"expect":"{Count:39}",
+				"expectMeta": [ ]
+			},
+			"servers": [ ]
 		}
 	]
 }
diff --git a/tests/afrouter/suites/test3.go b/tests/afrouter/suites/test3.go
new file mode 100644
index 0000000..88b4382
--- /dev/null
+++ b/tests/afrouter/suites/test3.go
@@ -0,0 +1,418 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"os"
+	"fmt"
+	//"flag"
+	//"path"
+	//"bufio"
+	"errors"
+	//"os/exec"
+	//"strconv"
+	"io/ioutil"
+	//"encoding/json"
+	"text/template"
+	//"github.com/golang/protobuf/proto"
+	"github.com/opencord/voltha-go/common/log"
+	//pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+)
+
+// This test suite validates that the different method types get routed
+// properly. That is, rw methods to the rw cores and ro methods to the
+// ro cores
+type test struct {
+	Name string
+	Core int
+	SerNo int
+	Method string
+	Param string
+	Expect string
+}
+
+type tests struct {
+	RoTests []test
+	RwTests []test
+	CtlTests []test
+}
+
+var roMethods []test = []test{
+    {
+		Name: "Test GetVoltha",
+		Method: "GetVoltha", // rpc GetVoltha(google.protobuf.Empty) returns(Voltha)
+		Param: "{}",
+		Expect:`{Version:\"abcdef\"}`,
+	},
+	/*
+    {
+		Name: "Test ListCoreInstances",
+		Method: "ListCoreInstances", // rpc ListCoreInstances(google.protobuf.Empty) returns(CoreInstances)
+		Param: "{}",
+		Expect:  `{Items:[]*voltha.CoreInstance{&voltha.CoreInstance{InstanceId:\"ABC\",Health:&voltha.HealthStatus{State:0}}}}`,
+	},
+	{
+		Name: "Test GetCoreInstance",
+		Method: "GetCoreInstance", // rpc GetCoreInstance(ID) returns(CoreInstance)
+		Param: `{Id:\"arou8390\"}`,
+		Expect: `{InstanceId:\"arou8390\", Health:&voltha.HealthStatus{State:0}}`,
+	},*/
+	{
+		Name: "Test ListAdapters",
+		Method: "ListAdapters", // rpc ListAdapters(google.protobuf.Empty) returns(Adapters)
+		Param: "{}",
+		Expect: `{Items:[]*voltha.Adapter{&voltha.Adapter{Id:\"ABC\", Vendor:\"afrouterTest\", Version:\"Version 1.0\"}}}`,
+	},
+	{
+		Name: "Test ListLogicalDevices",
+		Method: "ListLogicalDevices", // rpc ListLogicalDevices(google.protobuf.Empty) returns(LogicalDevices)
+		Param: "{}",
+		Expect:`{Items:[]*voltha.LogicalDevice{&voltha.LogicalDevice{Id:\"LDevId\", DatapathId:64, RootDeviceId:\"Root\"}}}`,
+	},
+	{
+		Name: "Test GetLogicalDevice",
+		Method: "GetLogicalDevice", // rpc GetLogicalDevice(ID) returns(LogicalDevice)
+		Param: `{Id:\"ABC123XYZ\"}`,
+		Expect:`{Id:\"ABC123XYZ\", DatapathId:64, RootDeviceId:\"Root-of:ABC123XYZ\"}`,
+	},
+	{
+		Name: "Test ListLogicalDevicePorts",
+		Method: "ListLogicalDevicePorts", // rpc ListLogicalDevicePorts(ID) returns(LogicalPorts)
+		Param: `{Id:\"ABC123XYZ\"}`,
+		Expect:`{Items:[]*voltha.LogicalPort{&voltha.LogicalPort{Id:\"PortId-1\", DeviceId:\"ABC12XYZ\", DevicePortNo:64, RootPort:true},&voltha.LogicalPort{Id:\"PortId-2\", DeviceId:\"ABC12XYZ\", DevicePortNo:64, RootPort:false}}}`,
+	},
+	{
+		Name: "Test GetLogicalDevicePort",
+		Method: "GetLogicalDevicePort", // rpc GetLogicalDevicePort(LogicalPortId) returns(LogicalPort)
+		Param: `{Id:\"PortId-1\"}`,
+		Expect:`{Id:\"PortId-1\", DeviceId:\"ABC12XYZ\", DevicePortNo:64, RootPort:true}`,
+	},
+	{
+		Name: "Test ListLogicalDeviceFlows",
+		Method: "ListLogicalDeviceFlows", // rpc ListLogicalDeviceFlows(ID) returns(openflow_13.Flows)
+		Param: `{Id:\"Flow-ABC123XYZ\"}`,
+		Expect:`{Items:[]*openflow_13.OfpFlowStats{&openflow_13.OfpFlowStats{Id:1, TableId:2, DurationSec:12, Priority:0},&openflow_13.OfpFlowStats{Id:1, TableId:2, DurationSec:12, Priority:0}}}`,
+	},
+	{
+		Name: "Test ListLogicalDeviceFlowGroups",
+		Method: "ListLogicalDeviceFlowGroups", // rpc ListLogicalDeviceFlowGroups(ID) returns(openflow_13.FlowGroups)
+		Param: `{Id:\"Flow-ABC123XYZ\"}`,
+		Expect:`{Items:[]*openflow_13.OfpGroupEntry{&openflow_13.OfpGroupEntry{Desc:&openflow_13.OfpGroupDesc{GroupId:12}, Stats:&openflow_13.OfpGroupStats{GroupId:1, RefCount:1, PacketCount:3}}}}`,
+	},
+	{
+		Name: "Test ListDevices",
+		Method: "ListDevices", // rpc ListDevices(google.protobuf.Empty) returns(Devices)
+		Param: `{}`,
+		Expect:`{Items:[]*voltha.Device{&voltha.Device{Id:\"ABC123XYZ\", Type:\"SomeDeviceType\", Root:false, ParentId:\"ZYX321CBA\"},&voltha.Device{Id:\"ZYX321CBA\", Type:\"SomeDeviceType\", Root:true, ParentId:\"ROOT\"}}}`,
+	},
+	{
+		Name: "Test ListDeviceIds",
+		Method: "ListDeviceIds", // rpc ListDeviceIds(google.protobuf.Empty) returns(IDs)
+		Param: `{}`,
+		Expect:`{Items:[]*voltha.ID{&voltha.ID{Id:\"ABC123XYZ\"},&voltha.ID{Id:\"ZYX321CBA\"}}}`,
+	},
+	{
+		Name: "Test GetDevice",
+		Method: "GetDevice", // rpc GetDevice(ID) returns(Device)
+		Param: `{Id:\"ZYX321CBA\"}`,
+		Expect:`{Id:\"ABC123XYZ\", Type:\"SomeDeviceType\", Root:false, ParentId:\"ZYX321CBA\"}`,
+	},
+	{
+		Name: "Test GetImageDownloadStatus",
+		Method: "GetImageDownloadStatus", // rpc GetImageDownloadStatus(ImageDownload) returns(ImageDownload)
+		Param: `{Id:\"Image-ZYX321CBA\"}`,
+		Expect:`{Id:\"Image-ABC123XYZ\", Name:\"SomeName\", Url:\"Some URL\", Crc:123456}`,
+	},
+	{
+		Name: "Test GetImageDownload",
+		Method: "GetImageDownload", // rpc GetImageDownload(ImageDownload) returns(ImageDownload)
+		Param: `{Id:\"Image-ZYX321CBA\"}`,
+		Expect:`{Id:\"Image-ABC123XYZ\", Name:\"SomeName\", Url:\"Some URL\", Crc:123456}`,
+	},
+	{
+		Name: "Test ListImageDownloads",
+		Method: "ListImageDownloads", // rpc ListImageDownloads(ID) returns(ImageDownloads)
+		Param: `{Id:\"ZYX321CBA\"}`,
+		Expect:`{Items:[]*voltha.ImageDownload{&voltha.ImageDownload{Id:\"Image1-ABC123XYZ\", Name:\"SomeName\", Url:\"Some URL\", Crc:123456}, &voltha.ImageDownload{Id:\"Image2-ABC123XYZ\", Name:\"SomeName\", Url:\"Some other URL\", Crc:654321}}}`,
+	},
+	{
+		Name: "Test ListDevicePorts",
+		Method: "ListDevicePorts", // rpc ListDevicePorts(ID) returns(Ports)
+		Param: `{}`,
+		Expect:`{Items:[]*voltha.Port{&voltha.Port{PortNo:100000, Label:\"Port one hundred thousand\", DeviceId:\"ZYX321CBA\"},&voltha.Port{PortNo:100001, Label:\"Port one hundred thousand and one\", DeviceId:\"ZYX321CBA\"}}}`,
+	},
+	{
+		Name: "Test ListDevicePmConfigs",
+		Method: "ListDevicePmConfigs", // rpc ListDevicePmConfigs(ID) returns(PmConfigs)
+		Param: `{}`,
+		Expect:`{Id:\"ABC123XYZ\", DefaultFreq: 10000, Grouped:false, FreqOverride:false, Metrics:[]*voltha.PmConfig{&voltha.PmConfig{Name:\"Speed\", Enabled: true, SampleFreq:10000}, &voltha.PmConfig{Name:\"Errors\", Enabled: true, SampleFreq:10000}}}`,
+	},
+	{
+		Name: "Test ListDeviceFlows",
+		Method: "ListDeviceFlows", // rpc ListDeviceFlows(ID) returns(openflow_13.Flows)
+		Param: `{Id:\"Flow-ABC123XYZ\"}`,
+		Expect:`{Items:[]*openflow_13.OfpFlowStats{&openflow_13.OfpFlowStats{Id:1, TableId:2, DurationSec:12, Priority:0},&openflow_13.OfpFlowStats{Id:1, TableId:2, DurationSec:12, Priority:0}}}`,
+	},
+	{
+		Name: "Test ListDeviceFlowGroups",
+		Method: "ListDeviceFlowGroups", // rpc ListDeviceFlowGroups(ID) returns(openflow_13.FlowGroups)
+		Param: `{Id:\"Flow-ABC123XYZ\"}`,
+		Expect:`{Items:[]*openflow_13.OfpGroupEntry{&openflow_13.OfpGroupEntry{Desc:&openflow_13.OfpGroupDesc{GroupId:12}, Stats:&openflow_13.OfpGroupStats{GroupId:1, RefCount:1, PacketCount:3}}}}`,
+	},
+	{
+		Name: "Test ListDeviceTypes",
+		Method: "ListDeviceTypes", // rpc ListDeviceTypes(google.protobuf.Empty) returns(DeviceTypes)
+		Param: `{}`,
+		Expect:`{Items:[]*voltha.DeviceType{&voltha.DeviceType{Id:\"ABC123XYZ\", VendorId:\"Ciena\", Adapter:\"SAOS\"},&voltha.DeviceType{Id:\"ZYX321CBA\", VendorId:\"Ciena\", Adapter:\"SAOS-Tibit\"}}}`,
+	},
+	{
+		Name: "Test GetDeviceType",
+		Method: "GetDeviceType", // rpc GetDeviceType(ID) returns(DeviceType)
+		Param: `{Id:\"ZYX321CBA\"}`,
+		Expect:`{Id:\"ZYX321CBA\", VendorId:\"Ciena\", Adapter:\"SAOS-Tibit\"}`,
+	},
+	{
+		Name: "Test ListDeviceGroups",
+		Method: "ListDeviceGroups", // rpc ListDeviceGroups(google.protobuf.Empty) returns(DeviceGroups)
+		Param: `{}`,
+		Expect:`{Items:[]*voltha.DeviceGroup{&voltha.DeviceGroup{Id:\"group-ABC123XYZ\", LogicalDevices: []*voltha.LogicalDevice{&voltha.LogicalDevice{Id:\"LDevId\", DatapathId:64, RootDeviceId:\"Root\"}}, Devices: []*voltha.Device{&voltha.Device{Id:\"ABC123XYZ\", Type:\"SomeDeviceType\", Root:false, ParentId:\"ZYX321CBA\"},&voltha.Device{Id:\"ZYX321CBA\", Type:\"SomeDeviceType\", Root:true, ParentId:\"ROOT\"}}}}}`,
+	},
+	{
+		Name: "Test GetDeviceGroup",
+		Method: "GetDeviceGroup", // rpc GetDeviceGroup(ID) returns(DeviceGroup)
+		Param: `{Id:\"ZYX321CBA\"}`,
+		Expect:`{Id:\"group-ABC123XYZ\", LogicalDevices: []*voltha.LogicalDevice{&voltha.LogicalDevice{Id:\"LDevId\", DatapathId:64, RootDeviceId:\"Root\"}}, Devices: []*voltha.Device{&voltha.Device{Id:\"ABC123XYZ\", Type:\"SomeDeviceType\", Root:false, ParentId:\"ZYX321CBA\"},&voltha.Device{Id:\"ZYX321CBA\", Type:\"SomeDeviceType\", Root:true, ParentId:\"ROOT\"}}}`,
+	},
+	{
+		Name: "Test ListAlarmFilters",
+		Method: "ListAlarmFilters", // rpc ListAlarmFilters(google.protobuf.Empty) returns(AlarmFilters)
+		Param: `{}`,
+		Expect:`{Filters:[]*voltha.AlarmFilter{&voltha.AlarmFilter{Id:\"ABC123XYZ\", Rules: []*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Value:\"Rule Value\"}}}}}`,
+	},
+	{
+		Name: "Test GetAlarmFilter",
+		Method: "GetAlarmFilter", // rpc GetAlarmFilter(ID) returns(AlarmFilter)
+		Param: `{Id:\"ABC123XYZ\"}`,
+		Expect:`{Id:\"ABC123XYZ\", Rules: []*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Value:\"Rule Value\"}}}`,
+	},
+	{
+		Name: "Test GetImages",
+		Method: "GetImages", // rpc GetImages(ID) returns(Images)
+		Param: `{Id:\"ZYX321CBA\"}`,
+		Expect:`{Image: []*voltha.Image{&voltha.Image{Name:\"Image1\", Version: \"0.1\", Hash:\"123@\", InstallDatetime:\"Yesterday\", IsActive:true, IsCommitted:true, IsValid:false},&voltha.Image{Name:\"Image2\", Version: \"0.2\", Hash:\"ABC@\", InstallDatetime:\"Today\", IsActive:false, IsCommitted:false, IsValid:false}}}`,
+	},
+}
+
+var ctlMethods []test = []test {
+	{
+		Name: "Test UpdateLogLevel",
+		Method: "UpdateLogLevel", // rpc UpdateLogLevel(Logging) returns(google.protobuf.Empty)
+		Param: `{Level: 0, PackageName:\"abc123\"}`,
+		Expect: "{}",
+	},
+}
+
+var rwMethods []test = []test{
+	{
+		Name: "Test EnableLogicalDevicePort",
+		Method: "EnableLogicalDevicePort", // rpc EnableLogicalDevicePort(LogicalPortId) returns(google.protobuf.Empty)
+		Param: `{Id:\"ZYX321CBA\", PortId:\"100,000\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test DisableLogicalDevicePort",
+		Method: "DisableLogicalDevicePort", // rpc DisableLogicalDevicePort(LogicalPortId) returns(google.protobuf.Empty)
+		Param: `{Id:\"ABC123XYZ\", PortId:\"100,000\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test UpdateLogicalDeviceFlowTable",
+		Method: "UpdateLogicalDeviceFlowTable", // rpc UpdateLogicalDeviceFlowTable(openflow_13.FlowTableUpdate)
+		Param: `{Id:\"XYZ123ABC\", FlowMod:&openflow_13.OfpFlowMod{Cookie:10, CookieMask:255, TableId:10000, Command:openflow_13.OfpFlowModCommand_OFPFC_ADD}}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test UpdateLogicalDeviceFlowGroupTable",
+		Method: "UpdateLogicalDeviceFlowGroupTable", // rpc UpdateLogicalDeviceFlowGroupTable(openflow_13.FlowGroupTableUpdate)
+		Param: `{Id:\"ZYX123ABC\", GroupMod:&openflow_13.OfpGroupMod{Command:openflow_13.OfpGroupModCommand_OFPGC_ADD, Type:openflow_13.OfpGroupType_OFPGT_INDIRECT, GroupId:255}}`,
+		Expect:`{}`,
+	},
+	//"ReconcileDevices", // rpc ReconcileDevices(IDs) returns(google.protobuf.Empty)
+	{
+		Name: "Test CreateDevice",
+		Method: "CreateDevice", // rpc CreateDevice(Device) returns(Device)
+		Param: `{Type:\"simulated_OLT\"}`,
+		Expect:`{Id:\"ZYX321ABC\", Type:\"\"}`,
+	},
+	{
+		Name: "Test EnableDevice",
+		Method: "EnableDevice", // rpc EnableDevice(ID) returns(google.protobuf.Empty)
+		Param: `{Id:\"XYZ321ABC\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test DisableDevice",
+		Method: "DisableDevice", // rpc DisableDevice(ID) returns(google.protobuf.Empty)
+		Param: `{Id:\"XYZ123CBA\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test RebootDevice",
+		Method: "RebootDevice", // rpc RebootDevice(ID) returns(google.protobuf.Empty)
+		Param: `{Id:\"ZYX123CBA\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test DeleteDevice",
+		Method: "DeleteDevice", // rpc DeleteDevice(ID) returns(google.protobuf.Empty)
+		Param: `{Id:\"CBA123XYZ\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test DownloadImage",
+		Method: "DownloadImage", // rpc DownloadImage(ImageDownload) returns(OperationResp)
+		Param: `{Id:\"CBA321XYZ\", Name:\"Image-1\", Crc: 54321}`,
+		Expect:`{Code:voltha.OperationResp_OPERATION_SUCCESS, AdditionalInfo:\"It worked!\"}`,
+	},
+	{
+		Name: "Test CancelImageDownload",
+		Method: "CancelImageDownload", // rpc CancelImageDownload(ImageDownload) returns(OperationResp)
+		Param: `{Id:\"CBA321ZYX\", Name:\"Image-1\", Crc: 54321}`,
+		Expect:`{Code:voltha.OperationResp_OPERATION_SUCCESS, AdditionalInfo:\"It worked!\"}`,
+	},
+	{
+		Name: "Test ActivateImageUpdate",
+		Method: "ActivateImageUpdate", // rpc ActivateImageUpdate(ImageDownload) returns(OperationResp)
+		Param: `{Id:\"ABC321ZYX\", Name:\"Image-1\", Crc: 54321}`,
+		Expect:`{Code:voltha.OperationResp_OPERATION_FAILURE, AdditionalInfo:\"It bombed!\"}`,
+	},
+	{
+		Name: "Test RevertImageUpdate",
+		Method: "RevertImageUpdate", // rpc RevertImageUpdate(ImageDownload) returns(OperationResp)
+		Param: `{Id:\"ABC123ZYX\", Name:\"Image-1\", Crc: 54321}`,
+		Expect:`{Code:voltha.OperationResp_OPERATION_FAILURE, AdditionalInfo:\"It bombed!\"}`,
+	},
+	{
+		Name: "Test UpdateDevicePmConfigs",
+		Method: "UpdateDevicePmConfigs", // rpc UpdateDevicePmConfigs(voltha.PmConfigs) returns(google.protobuf.Empty)
+		Param: `{Id:\"CBA123ZYX\", DefaultFreq:1000000, Grouped: false, FreqOverride: false}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test CreateAlarmFilter",
+		Method: "CreateAlarmFilter", // rpc CreateAlarmFilter(AlarmFilter) returns(AlarmFilter)
+		Param: `{Id:\"abc123xyz\", Rules:[]*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_type, Value:\"Type man, it's the type!\"}, &voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_category, Value:\"Category yeah!\"}}}`,
+		Expect:`{Id:\"abc123xyz\", Rules: []*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_type, Value:\"Type man, it's the type!\"}, &voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_category, Value:\"Category yeah!\"}}}`,
+	},
+	{
+		Name: "Test UpdateAlarmFilter",
+		Method: "UpdateAlarmFilter", // rpc UpdateAlarmFilter(AlarmFilter) returns(AlarmFilter)
+		Param: `{Id:\"ABC321XYZ\", Rules:[]*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_type, Value:\"Type man, it's the type!\"}, &voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_category, Value:\"Category yeah!\"}}}`,
+		Expect:`{Id:\"ABC321XYZ\", Rules: []*voltha.AlarmFilterRule{&voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_type, Value:\"Type man, it's the type!\"}, &voltha.AlarmFilterRule{Key:voltha.AlarmFilterRuleKey_category, Value:\"Category yeah!\"}}}`,
+	},
+	{
+		Name: "Test DeleteAlarmFilter",
+		Method: "DeleteAlarmFilter", // rpc DeleteAlarmFilter(ID) returns(google.protobuf.Empty)
+		Param: `{Id:\"acb123xyz\"}`,
+		Expect:`{}`,
+	},
+	{
+		Name: "Test SelfTest",
+		Method: "SelfTest", // rpc SelfTest(ID) returns(SelfTestResponse)
+		Param: `{Id:\"bac123xyz\"}`,
+		Expect:`{Result:voltha.SelfTestResponse_UNKNOWN_ERROR}`,
+	},
+} /*
+//    "StreamPacketsOut", // rpc StreamPacketsOut(stream openflow_13.PacketOut)
+//    "ReceivePacketsIn", // rpc ReceivePacketsIn(google.protobuf.Empty)
+//    "ReceiveChangeEvents", // rpc ReceiveChangeEvents(google.protobuf.Empty)
+    "Subscribe ", // rpc Subscribe (OfAgentSubscriber) returns (OfAgentSubscriber)
+
+}
+*/
+
+func dumpFile(fileNm string) error {
+	// Dump the generated file for debugging purposes
+	if c,err := ioutil.ReadFile(fileNm); err == nil {
+		fmt.Print(string(c))
+	} else {
+		e := errors.New(fmt.Sprintf("Could not read the file '%s', %v", fileNm, err))
+		return e
+	}
+	return nil
+}
+
+func main() {
+
+	//var rwAry []test
+	//var roAry []test
+	var serNo int = 0
+
+	// Setup logging
+	if _, err := log.SetDefaultLogger(log.JSON, 0, nil); err != nil {
+		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
+	}
+
+	core := 0
+	for  k,_ := range roMethods {
+		roMethods[k].SerNo = serNo
+		roMethods[k].Core = (core%3) + 1
+		log.Infof("Processing method %s, serNo: %d", roMethods[k].Method, roMethods[k].SerNo)
+		serNo++
+		core++
+	}
+
+	// New round robin starts here because of the different route
+	core = 0
+	for  k,_ := range rwMethods {
+		rwMethods[k].SerNo = serNo
+		rwMethods[k].Core = (core%3) + 1
+		log.Infof("Processing method %s, serNo: %d", rwMethods[k].Method, rwMethods[k].SerNo)
+		serNo++
+		core++
+	}
+
+	// New round robin starts here because of the different route
+	core = 0
+	for  k,_ := range ctlMethods {
+		ctlMethods[k].SerNo = serNo
+		ctlMethods[k].Core = (core%3) + 1
+		log.Infof("Processing method %s, serNo: %d", ctlMethods[k].Method, ctlMethods[k].SerNo)
+		serNo++
+		core++
+	}
+
+	tsts := tests{RoTests: roMethods, RwTests: rwMethods, CtlTests: ctlMethods}
+
+	t := template.Must(template.New("").ParseFiles("./test3.tmpl.json"))
+	if f,err := os.Create("test3.json"); err == nil {
+		_=f
+		defer f.Close()
+		if err := t.ExecuteTemplate(f, "test3.tmpl.json", tsts); err != nil {
+			log.Errorf("Unable to execute template for test3.tmpl.json: %v", err)
+		}
+	} else {
+		log.Errorf("Couldn't create file test3.json: %v", err)
+	}
+
+	// Dump the generated file for debugging purposes
+	//if err := dumpFile("test3.json"); err != nil {
+	//	log.Error(err)
+	//}
+
+
+}
diff --git a/tests/afrouter/suites/test3.json b/tests/afrouter/suites/test3.json
deleted file mode 100644
index 2d3d7ad..0000000
--- a/tests/afrouter/suites/test3.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
-	"environment":{
-		"cmdLine":"afrouter -config arouter_test.json",
-		"protoFiles": [
-			{
-				"importPath":"github.com/opencord/voltha-go/protos/",
-				"service":"VolthaService",
-				"package":"voltha"
-			}
-		],
-		"imports": [
-			 "github.com/golang/protobuf/ptypes/empty",
-			 "github.com/opencord/voltha-go/protos/openflow_13"
-		],
-		"protoDesc":"voltha.pb",
-		"protoSubst": [
-			{
-				"from":"google.protobuf.Empty",
-				"to":"empty.Empty"
-			}
-		],
-		"clients": [
-			{
-				"name":"client",
-				"port":"5000"
-			}
-		],
-		"servers": [
-			{
-				"name":"core11",
-				"port":"5011"
-			},
-			{
-				"name":"core12",
-				"port":"5012"
-			},
-			{
-				"name":"core21",
-				"port":"5021"
-			},
-			{
-				"name":"core22",
-				"port":"5022"
-			},
-			{
-				"name":"core31",
-				"port":"5031"
-			},
-			{
-				"name":"core32",
-				"port":"5032"
-			}
-		]
-	},
-	"tests":[
-		{
-			"send": {
-				"client":"client",
-				"method":"CreateDevice",
-				"param":"json struct",
-				"_meta":""
-			},
-			"servers": [
-				{
-					"name":"server11",
-					"meta": [
-						{
-							"key":"voltha_serial_number",
-							"value":"1"
-						}
-					],
-					"param":"mirror_client"
-				},
-				{
-					"name":"server12",
-					"meta": [
-						{
-							"key":"voltha_serial_number",
-							"value":"1"
-						}
-					],
-					"param":"mirror_client"
-				}
-			]
-		}
-	]
-}
diff --git a/tests/afrouter/suites/test3.tmpl.json b/tests/afrouter/suites/test3.tmpl.json
new file mode 100644
index 0000000..b3118ff
--- /dev/null
+++ b/tests/afrouter/suites/test3.tmpl.json
@@ -0,0 +1,235 @@
+{
+	"environment":{
+		"cmdLine":"afrouter -config arouter_test.json -logLevel 1",
+		"protoFiles": [
+			{
+				"importPath":"github.com/opencord/voltha-go/protos/",
+				"service":"VolthaService",
+				"package":"voltha"
+			},
+			{
+				"importPath":"github.com/opencord/voltha-go/protos/",
+				"service":"Configuration",
+				"package":"afrouter"
+			}
+		],
+		"imports": [
+			"github.com/golang/protobuf/ptypes/empty",
+			"github.com/opencord/voltha-go/protos/openflow_13"
+		],
+		"protoDesc":"voltha.pb",
+		"protoSubst": [
+			{
+				"from":"google.protobuf.Empty",
+				"to":"empty.Empty"
+			}
+		],
+		"clients": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
+				{
+					"name":"client",
+					"port":"5000"
+				},
+				{
+					"name":"stats",
+					"port":"55554"
+				}
+			]
+		},
+		"servers": {
+			"imports": [
+				 "github.com/golang/protobuf/ptypes/empty",
+				 "github.com/opencord/voltha-go/protos/openflow_13"
+			],
+			"endpoints": [
+			{
+				"name":"core11",
+				"port":"5011"
+			},
+			{
+				"name":"core12",
+				"port":"5012"
+			},
+			{
+				"name":"core21",
+				"port":"5021"
+			},
+			{
+				"name":"core22",
+				"port":"5022"
+			},
+			{
+				"name":"core31",
+				"port":"5031"
+			},
+			{
+				"name":"core32",
+				"port":"5032"
+			},
+			{
+				"name":"roCore1",
+				"port":"5001"
+			},
+			{
+				"name":"roCore2",
+				"port":"5002"
+			},
+			{
+				"name":"roCore3",
+				"port":"5003"
+			}
+			]
+		}
+	},
+	"tests":[
+		{{range $k,$v := .RoTests}}
+		{
+			"name":"{{$v.Name}}",
+			"send": {
+				"client":"client",
+				"method":"{{$v.Method}}",
+				"param":"{{$v.Param}}",
+				"expect":"{{$v.Expect}}",
+				"_meta":""
+			},
+			"servers": [
+				{
+					"name":"core{{$v.Core}}1",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				},
+				{
+					"name":"core{{$v.Core}}2",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				}
+			]
+		},
+		{{end}}
+		{{range $k,$v := .RwTests}}
+		{
+			"name":"{{$v.Name}}",
+			"send": {
+				"client":"client",
+				"method":"{{$v.Method}}",
+				"param":"{{$v.Param}}",
+				"expect":"{{$v.Expect}}",
+				"_meta":""
+			},
+			"servers": [
+				{
+					"name":"core{{$v.Core}}1",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				},
+				{
+					"name":"core{{$v.Core}}2",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				}
+			]
+		},
+		{{end}}
+		{{range $k,$v := .CtlTests}}
+		{
+			"name":"{{$v.Name}}",
+			"send": {
+				"client":"client",
+				"method":"{{$v.Method}}",
+				"param":"{{$v.Param}}",
+				"expect":"{{$v.Expect}}",
+				"_meta":""
+			},
+			"servers": [
+				{
+					"name":"core{{$v.Core}}1",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				},
+				{
+					"name":"core{{$v.Core}}2",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"{{$v.SerNo}}"
+						}
+					]
+				}
+			]
+		},
+		{{end}}
+		{
+			"name":"Test Subscribe",
+			"send": {
+				"client":"client",
+				"method":"Subscribe",
+				"param":"{OfagentId:\"Agent007\"}",
+				"meta": [
+					{
+						"key":"voltha_backend_name",
+						"value":""
+					}
+				],
+				"expect":"{OfagentId:\"Agent007\",VolthaId:\"core11\"}",
+				"expectMeta": [
+					{
+						"key":"voltha_backend_name",
+						"value":"vcore1"
+					}
+				]
+			},
+			"servers": [
+				{
+					"name":"core11",
+					"meta": [
+						{
+							"key":"voltha_serial_number",
+							"value":"44"
+						},
+						{
+							"key":"voltha_backend_name",
+							"value":""
+						}
+					]
+				}
+			]
+		},
+		{
+			"_COMMENT":"If this test case fails, there could be a goroutine leak",
+			"name":"Get goroutine count",
+			"send": {
+				"client":"stats",
+				"method":"GetGoroutineCount",
+				"param":"{}",
+				"meta": [ ],
+				"expect":"{Count:39}",
+				"expectMeta": [ ]
+			},
+			"servers": [ ]
+		}
+	]
+}
diff --git a/tests/afrouter/templates/client.go b/tests/afrouter/templates/client.go
index 8cd3330..db34efd 100644
--- a/tests/afrouter/templates/client.go
+++ b/tests/afrouter/templates/client.go
@@ -99,7 +99,7 @@
 			// value.
 			if resS,err := json.Marshal(res); err == nil {
 				if string(resS) != expect {
-					resFile.testLog("Unexpected result returned\n")
+					stats.testLog("Unexpected result returned expected '%s' got '%s'\n", expect, string(resS))
 					return errors.New("Unexpected result on method {{.Name}}")
 				}
 			} else {
@@ -109,11 +109,11 @@
 			for k,v := range expectMeta {
 				if rv,ok := hdr[k]; ok == true {
 					if rv[0] != v[0] {
-						resFile.testLog("Mismatch on returned metadata for key '%s' expected '%s' and got '%s'\n", k, v, rv)
+						stats.testLog("Mismatch on returned metadata for key '%s' expected '%s' and got '%s'\n", k, v, rv)
 						err = errors.New("Failure on returned metadata")
 					}
 				} else {
-					resFile.testLog("Returned metadata missing key '%s'; expected value '%s' at that key\n", k, v)
+					stats.testLog("Returned metadata missing key '%s'; expected value '%s' at that key\n", k, v)
 					err = errors.New("Failure on returned metadata")
 				}
 			}
diff --git a/tests/afrouter/templates/main.go b/tests/afrouter/templates/main.go
index c2fddb9..0361460 100644
--- a/tests/afrouter/templates/main.go
+++ b/tests/afrouter/templates/main.go
@@ -21,74 +21,15 @@
 
 import (
 	"os"
-	"fmt"
 	"time"
 	"os/exec"
 	"strings"
 	"context"
-	slog "log"
-	"io/ioutil"
-	"encoding/json"
-	"google.golang.org/grpc/grpclog"
+	//slog "log"
+	//"google.golang.org/grpc/grpclog"
 	"github.com/opencord/voltha-go/common/log"
 )
 
-type TestCase struct {
-	Title string `json:"title"`
-	Result bool `json:"result"`
-	Info []string `json:"info"`
-}
-
-type TestSuite struct {
-	Name string `json:"name"`
-	TestCases []TestCase `json:"testCases"`
-}
-
-type TestRun struct {
-	TestSuites []TestSuite
-}
-
-var resFile *tstLog
-type tstLog struct {
-	fp * os.File
-	fn string
-}
-
-func (tr * tstLog) testLog(format string, a ...interface{}) {
-	var err error
-	if tr.fp == nil {
-		if tr.fp, err = os.OpenFile(tr.fn, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err != nil {
-			log.Errorf("Could not append to the results file")
-			tr.fp = nil
-		}
-	}
-	if tr.fp != nil {
-		tr.fp.Write([]byte(fmt.Sprintf(format, a...)))
-	}
-}
-
-func (tr * tstLog) testLogOnce(format string, a ...interface{}) {
-	var err error
-	if tr.fp == nil {
-		if tr.fp, err = os.OpenFile(tr.fn, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err != nil {
-			log.Errorf("Could not append to the results file")
-			tr.fp = nil
-		}
-	}
-	if tr.fp != nil {
-		tr.fp.Write([]byte(fmt.Sprintf(format, a...)))
-	}
-	tr.fp.Close()
-	tr.fp = nil
-}
-
-func (tr * tstLog) close() {
-	if tr.fp != nil {
-		tr.fp.Close()
-	}
-}
-
-
 func startSut(cmdStr string) (*exec.Cmd, context.CancelFunc, error) {
 	var err error = nil
 
@@ -109,58 +50,35 @@
 
 func cleanUp(cmd *exec.Cmd, cncl context.CancelFunc) {
 	cncl()
-	cmd.Wait() // This seems to hang
-	// Give the child processes time to terminate
-	//time.Sleep(1 * time.Second)
+	cmd.Wait()
 }
 
-func readStats(stats * TestRun) () {
-	// Check if the  stats file exists
-	if _,err := os.Stat("stats.json"); err != nil {
-		// Nothing to do, just return
-		return
-	}
-	// The file is there, read it an unmarshal it into the stats struct
-	if statBytes, err := ioutil.ReadFile("stats.json"); err != nil {
-		log.Error(err)
-		return
-	} else if err := json.Unmarshal(statBytes, stats); err != nil {
-		log.Error(err)
-		return
-	}
-}
-
-func writeStats(stats * TestRun) () {
-	// Check if the  stats file exists
-	// The file is there, read it an unmarshal it into the stats struct
-	if statBytes, err := json.MarshalIndent(stats, "","    "); err != nil {
-		log.Error(err)
-		return
-	} else if err := ioutil.WriteFile("stats.json.new", statBytes, 0644); err != nil {
-		log.Error(err)
-		return
-	}
-	os.Rename("stats.json", "stats.json~")
-	os.Rename("stats.json.new", "stats.json")
-}
-var stats TestRun
-
 func main() {
 	var err error
 
 	// Setup logging
-	if _, err = log.SetDefaultLogger(log.JSON, 0, nil); err != nil {
+	if _, err = log.SetDefaultLogger(log.JSON, 1, nil); err != nil {
 		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
 	}
 	defer log.CleanUp()
 
-	readStats(&stats)
+	if len(os.Args) < 2 {
+		log.Fatalf("Stat file name parameter missing for %s. Aborting...", os.Args[0])
+	} else {
+		statFn = os.Args[1]
+	}
 
+	if stats,err = readStats(statFn); err != nil {
+		log.Error(err)
+		return
+	}
+	defer writeStats(statFn, stats)
 
-	grpclog.SetLogger(slog.New(os.Stderr, "grpc: ", slog.LstdFlags))
+	// Add a stat entry for this run
 
-	resFile = &tstLog{fn:os.Args[1]}
-	defer resFile.close()
+	stats.appendNew()
+	tsIdx :=  len(stats.TestSuites) - 1
+	stats.TestSuites[tsIdx].Name = os.Args[0]
 
 
 	// Initialize the servers
@@ -186,7 +104,8 @@
 
 	// Run all the test cases now
 	log.Infof("Executing tests")
+
+	//log.Infof("Stats struct: %v", stats)
 	runTests()
-	writeStats(&stats)
 
 }
diff --git a/tests/afrouter/templates/runAll.go b/tests/afrouter/templates/runAll.go
index 03cdab1..5b02376 100644
--- a/tests/afrouter/templates/runAll.go
+++ b/tests/afrouter/templates/runAll.go
@@ -28,44 +28,6 @@
 	"github.com/opencord/voltha-go/common/log"
 )
 
-type tstLog struct {
-	fp * os.File
-	fn string
-}
-
-func (tr * tstLog) testLog(format string, a ...interface{}) {
-	var err error
-	if tr.fp == nil {
-		if tr.fp, err = os.OpenFile(tr.fn, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err != nil {
-			log.Errorf("Could not append to the results file")
-			tr.fp = nil
-		}
-	}
-	if tr.fp != nil {
-		tr.fp.Write([]byte(fmt.Sprintf(format, a...)))
-	}
-}
-
-func (tr * tstLog) testLogOnce(format string, a ...interface{}) {
-	var err error
-	if tr.fp == nil {
-		if tr.fp, err = os.OpenFile(tr.fn, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err != nil {
-			log.Errorf("Could not append to the results file")
-			tr.fp = nil
-		}
-	}
-	if tr.fp != nil {
-		tr.fp.Write([]byte(fmt.Sprintf(format, a...)))
-	}
-	tr.fp.Close()
-	tr.fp = nil
-}
-
-func (tr * tstLog) close() {
-	if tr.fp != nil {
-		tr.fp.Close()
-	}
-}
 
 func main() {
 	var cmd *exec.Cmd
@@ -77,17 +39,23 @@
 
 	defer log.CleanUp()
 
+	statFn = "stats.json"
+
 	log.Info("Running tests")
 	if err:= os.Chdir(os.Args[1]); err != nil {
 		log.Error("Could not change directory to %s: %v", os.Args[1], err)
 	}
-	tl := &tstLog{fn:"results.txt"}
+
+	if err := initStats(statFn); err != nil {
+		log.Error(err)
+		return
+	}
+
 	{{range .}}
 	cmdStr =  "./"+"{{.}}"+".e"
-	tl.testLogOnce("Running test suite '%s'\n", cmdStr[2:])
 
 	log.Infof("Running test suite %s",cmdStr)
-	cmd = exec.Command(cmdStr, "results.txt")
+	cmd = exec.Command(cmdStr, statFn)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -96,10 +64,36 @@
 	}
 	{{end}}
 	// Open the results file and output it.
-	if resFile, err := ioutil.ReadFile("results.txt"); err == nil {
+	if s,err := readStats(statFn); err != nil {
+		log.Error(err)
+		return
+	} else {
+		stats = s
+	}
+
+	//log.Infof("Stats are: %v", stats)
+	if resFile, err := ioutil.ReadFile(statFn); err == nil {
 		fmt.Println(string(resFile))
 	} else {
-		log.Error("Could not load the results file 'results.txt'")
+		log.Error("Could not load the stats file 'stats.json'")
+	}
+	fmt.Println("Test result summary")
+	for _,v := range stats.TestSuites {
+		fmt.Printf("Test suite: %s\n", v.Name[2:len(v.Name)-2])
+		pass := 0
+		fail := 0
+		total := 0
+		for _,v1 := range v.TestCases {
+			total++
+			if v1.Result == true {
+				pass++
+			} else {
+				fail++
+			}
+		}
+		fmt.Printf("\tTotal test cases: %d\n", total)
+		fmt.Printf("\t\tTotal passed test cases: %d\n", pass)
+		fmt.Printf("\t\tTotal failed test cases: %d\n", fail)
 	}
 	log.Info("Tests complete")
 }
diff --git a/tests/afrouter/templates/runTests.go b/tests/afrouter/templates/runTests.go
index 61ba5eb..ac58220 100644
--- a/tests/afrouter/templates/runTests.go
+++ b/tests/afrouter/templates/runTests.go
@@ -18,6 +18,7 @@
 package main
 
 import (
+{{if .HasFuncs}}
 	"fmt"
 	"time"
 	"errors"
@@ -26,14 +27,22 @@
 	//"golang.org/x/net/context"
 	"google.golang.org/grpc/metadata"
 	"github.com/opencord/voltha-go/common/log"
+{{end}}
 	{{range .Imports}}
-	_ "{{.}}"
+	{{if .Used}}
+	"{{.Package}}"
+	{{end}}
 	{{end}}
 	{{range .ProtoImports}}
+	{{if .Used}}
 	{{.Short}} "{{.Package}}"
 	{{end}}
+	{{end}}
 )
 
+
+{{if .FileNum}}
+{{else}}
 var glCtx context.Context
 
 func resetChannels() {
@@ -54,70 +63,148 @@
 	}
 }
 
-func runTests() {
-	{{range $k,$v := .Tests}}
-	if err := test{{$k}}(); err == nil {
-		resFile.testLog("\tTest Successful\n")
-	} else {
-		resFile.testLog("\tTest Failed\n")
-	}
-	//resetChannels()
-	{{end}}
+type testData struct {
+	function func(int, string, string, []string,[]string,[]string,
+				  map[string][]string,interface{}, interface{}) error
+	testNum int
+	testName string
+	sendClient string
+	srvrs []string
+	sendMeta []string
+	expectMeta []string // Send Meta
+	srvMeta map[string][]string
+	parm interface{}
+	ret interface{}
 }
 
-{{range $k,$v := .Tests}}
-func test{{$k}}() error {
+func addTestSlot(stats * TestRun) {
+	tsIdx := len(stats.TestSuites) - 1
+	stats.TestSuites[tsIdx].TestCases =
+			append(stats.TestSuites[tsIdx].TestCases, TestCase{Info:[]string{}})
+}
+{{end}}
+
+{{if .FileNum}}
+func runTests{{.FileNum}}() {
+{{else}}
+func runTests() {
+{{end}}
+	tsIdx := len(stats.TestSuites) - 1
+	tests := []testData {
+	{{$ofs := .Offset}}
+	{{range $k,$v := .Tests}}
+	testData {
+		{{$v.Send.Method}}_test,
+		{{$k}} + {{$ofs}},
+		"{{$v.Name}}",
+		"{{$v.Send.Client}}",
+		[]string{ {{range $sk,$sv := $v.Srvr}} "{{$sv.Name}}",{{end}} },
+		[]string{ {{range $mk,$mv := $v.Send.MetaData}}"{{$mv.Key}}","{{$mv.Val}}",{{end}} },
+		[]string{ {{range $mk,$mv := $v.Send.ExpectMeta}}"{{$mv.Key}}","{{$mv.Val}}",{{end}} },
+		map[string][]string {
+		{{range $sk,$sv := $v.Srvr}}
+			"{{$sv.Name}}":[]string {
+			{{range $mk, $mv := $sv.Meta}}
+				 "{{$mv.Key}}","{{$mv.Val}}",
+			{{end}}
+			},
+		{{end}}
+		},
+		&{{$v.Send.ParamType}}{{$v.Send.Param}},
+		&{{$v.Send.ExpectType}}{{$v.Send.Expect}},
+	},
+	{{end}}
+	}
+
+	for _,v := range tests {
+		addTestSlot(stats)
+		stats.TestSuites[tsIdx].TestCases[v.testNum].Title = v.testName
+		if err := v.function(
+			v.testNum,
+			v.testName,
+			v.sendClient,
+			v.srvrs,
+			v.sendMeta,
+			v.expectMeta,
+			v.srvMeta,
+			v.parm,
+			v.ret); err != nil {
+			stats.TestSuites[tsIdx].TestCases[v.testNum].Result = false
+		} else {
+			stats.TestSuites[tsIdx].TestCases[v.testNum].Result = true
+		}
+	}
+	{{if .FileNum}}
+	{{else}}
+	{{range $k,$v := .RunTestsCallList}}
+	{{$v}}()
+	{{end}}
+	{{end}}
+	return
+	//resetChannels()
+}
+
+{{range $k,$v := .Funcs }}
+{{if $v.CodeGenerated}}
+{{else}}
+func {{$k}}_test(testNum int, testName string, sendClient string, srvrs []string,
+				 sendMeta []string, expectMeta []string, srvrMeta map[string][]string,
+				 parm interface{}, ret interface{}) error {
+
 	var rtrn error = nil
 	var cancel context.CancelFunc
+	var repl *reply
 
+	log.Debug("Running Test %d",testNum)
 	glCtx, cancel = context.WithTimeout(context.Background(), 900*time.Millisecond)
 	defer cancel()
-	// Announce the test being run
-	resFile.testLog("******************** Running test case ({{$k}}): {{$v.Name}}\n")
-	// Acquire the client used to run the test
-	cl := clients["{{$v.Send.Client}}"]
+
+	cl := clients[sendClient]
 	// Create the server's reply data structure
-	repl := &reply{repl:&{{$v.Send.ExpectType}}{{$v.Send.Expect}}}
-	// Send the reply data structure to each of the servers
-	{{range $s := .Srvr}}
-	if servers["{{$s.Name}}"] == nil {
-		err := errors.New("Server '{{$s.Name}}' is nil")
-		log.Error(err)
-		return err
+	switch r := ret.(type) {
+	case *{{$v.ReturnType}}:
+		repl = &reply{repl:r}
+	default:
+		log.Errorf("Invalid type in call to {{$k}}_test expecting {{$v.ReturnType}} got %T", ret)
 	}
-	// Start a go routine to send the the reply data to the
-	// server. The go routine blocks until the server picks
-	// up the data or the timeout is exceeded.
-	go func (ctx context.Context) {
-		select {
-		case servers["{{$s.Name}}"].replyData <- repl:
-		case <-ctx.Done():
-			rtrn := errors.New("Could not provide server {{$s.Name}} with reply data")
-			log.Error(rtrn)
-			resFile.testLog("%s\n", rtrn.Error())
+	// Send the reply data structure to each of the servers
+	for _,v := range srvrs {
+		if servers[v] == nil {
+			err := errors.New(fmt.Sprintf("Server %s is nil", v))
+			log.Error(err)
+			return err
 		}
-	}(glCtx)
-	{{end}}
+		// Start a go routine to send the the reply data to the
+		// server. The go routine blocks until the server picks
+		// up the data or the timeout is exceeded.
+		go func (ctx context.Context, srv string) {
+			select {
+			case servers[srv].replyData <- repl:
+			case <-ctx.Done():
+				rtrn := errors.New(fmt.Sprintf("Could not provide server %s with reply data",srv))
+				log.Error(rtrn)
+				stats.testLog("%s\n", rtrn.Error())
+			}
+		}(glCtx,v)
+	}
 
 	// Now call the RPC with the data provided
 	if expct,err := json.Marshal(repl.repl); err != nil {
-		log.Errorf("Marshaling the reply for test {{$v.Name}}: %v",err)
+		log.Errorf("Marshaling the reply for test %s: %v",testName, err)
 	} else {
 		// Create the context for the call
 		ctx := context.Background()
-		{{range $m := $v.Send.MetaData}}
-		ctx = metadata.AppendToOutgoingContext(ctx, "{{$m.Key}}", "{{$m.Val}}")
-		{{end}}
+		for i:=0; i<len(sendMeta); i += 2 {
+			ctx = metadata.AppendToOutgoingContext(ctx, sendMeta[i], sendMeta[i+1])
+		}
 		var md map[string]string = make(map[string]string)
-		{{range $m := $v.Send.ExpectMeta}}
-			md["{{$m.Key}}"] = "{{$m.Val}}"
-		{{end}}
+		for i:=0; i<len(expectMeta); i+=2 {
+			md[expectMeta[i]] = expectMeta[i+1]
+		}
 		expectMd := metadata.New(md)
-		if err := cl.send("{{$v.Send.Method}}", ctx,
-							&{{$v.Send.ParamType}}{{$v.Send.Param}},
-							string(expct), expectMd); err != nil {
-			log.Errorf("Test case {{$v.Name}} failed!: %v", err)
-
+		if err := cl.send("{{$k}}", ctx, parm, string(expct), expectMd); err != nil {
+			log.Errorf("Test case %s failed!: %v", testName, err)
+			rtrn = err
 		}
 	}
 
@@ -125,39 +212,38 @@
 	var s *serverCtl
 	var payload string
 	var i *incoming
-	if pld, err := json.Marshal(&{{$v.Send.ParamType}}{{$v.Send.Param}}); err != nil {
-		log.Errorf("Marshaling paramter for test {{$v.Name}}: %v", err)
+	if pld, err := json.Marshal(parm); err != nil {
+		log.Errorf("Marshaling paramter for test %s: %v", testName, err)
 	} else {
 		payload = string(pld)
 	}
-	{{range $s := .Srvr}}
-	s = servers["{{$s.Name}}"]
-	// Oddly sometimes the data isn't in the channel yet when we come to read it.
-	select {
-	case i = <-s.incmg:
-		if i.payload != payload {
-			rtrn = errors.New(fmt.Sprintf("Mismatched payload expected '%s', got '%s'", payload, i.payload))
-			log.Error(rtrn.Error())
-			resFile.testLog("%s\n", rtrn.Error())
-		}
-		{{range $m := $s.Meta}}
-		if mv,ok := i.meta["{{$m.Key}}"]; ok == true {
-			if "{{$m.Val}}" != mv[0] {
-				rtrn=errors.New(fmt.Sprintf("Mismatched metadata on server '%s' expected '%s', got '%s'", "{{$s.Name}}", "{{$m.Val}}", mv[0]))
+	for _,v := range srvrs {
+		s = servers[v]
+		// Oddly sometimes the data isn't in the channel yet when we come to read it.
+		select {
+		case i = <-s.incmg:
+			if i.payload != payload {
+				rtrn = errors.New(fmt.Sprintf("Mismatched payload expected '%s', got '%s'", payload, i.payload))
 				log.Error(rtrn.Error())
-				resFile.testLog("%s\n", rtrn.Error())
+				stats.testLog("%s\n", rtrn.Error())
 			}
+			for j:=0; j<len(srvrMeta[v]); j+=2 {
+				if mv,ok := i.meta[srvrMeta[v][j]]; ok == true {
+					if srvrMeta[v][j+1] != mv[0] {
+						rtrn=errors.New(fmt.Sprintf("Mismatched metadata on server '%s' expected '%s', got '%s'", srvrMeta[v][j], srvrMeta[v][j+1], mv[0]))
+						log.Error(rtrn.Error())
+						stats.testLog("%s\n", rtrn.Error())
+					}
+				}
+			}
+		case <-glCtx.Done():
+			rtrn = errors.New(fmt.Sprintf("Timeout: no response data available for server %s", testName))
+			stats.testLog("%s\n", rtrn.Error())
+			log.Error(rtrn)
 		}
-		{{end}}
-	case <-glCtx.Done():
-		rtrn = errors.New("Timeout: no response data available for server {{$s.Name}}")
-		resFile.testLog("%s\n", rtrn.Error())
-		log.Error(rtrn)
 	}
-	{{end}}
 
 	return rtrn
 }
 {{end}}
-
-
+{{end}}
diff --git a/tests/afrouter/templates/server.go b/tests/afrouter/templates/server.go
index ffea3d5..0f9ed48 100644
--- a/tests/afrouter/templates/server.go
+++ b/tests/afrouter/templates/server.go
@@ -123,7 +123,7 @@
 {{else}}
 func  (ts {{$.Name}}TestServer) {{.Name}}(ctx context.Context, in *{{.Param}}) (*{{.Rtrn}}, error) {
 	var r * incoming = &incoming{}
-	log.Debug("Serving {{$.Name}}")
+	//log.Debug("Serving {{$.Name}}")
 	// Read the metadata
 	if md,ok := metadata.FromIncomingContext(ctx); ok == false {
 		log.Error("Getting matadata during call to {{.Name}}")
diff --git a/tests/afrouter/templates/stats.go b/tests/afrouter/templates/stats.go
new file mode 100644
index 0000000..958bea7
--- /dev/null
+++ b/tests/afrouter/templates/stats.go
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// The template for the tester.
+// This template is filled in by the
+// test driver based on the configuration.
+
+package main
+
+import (
+	"os"
+	"fmt"
+	//slog "log"
+	"io/ioutil"
+	"encoding/json"
+	//"google.golang.org/grpc/grpclog"
+	"github.com/opencord/voltha-go/common/log"
+)
+
+type TestCase struct {
+	Title string `json:"title"`
+	Result bool `json:"passed"`
+	Info []string `json:"info"`
+}
+
+type TestSuite struct {
+	Name string `json:"name"`
+	Info []string `json:"info"`
+	TestCases []TestCase `json:"testCases"`
+}
+
+type TestRun struct {
+	TestSuites []TestSuite
+}
+
+func (tr * TestRun) testLog(format string, a ...interface{}) {
+
+	tridx := len(tr.TestSuites) - 1
+	tcidx := len(tr.TestSuites[tridx].TestCases) - 1
+
+	tr.TestSuites[tridx].TestCases[tcidx].Info =
+			append(tr.TestSuites[tridx].TestCases[tcidx].Info, fmt.Sprintf(format, a...))
+
+}
+
+func (tr * TestRun) suiteLog(format string, a ...interface{}) {
+
+	tridx := len(tr.TestSuites) - 1
+
+	tr.TestSuites[tridx].Info =
+			append(tr.TestSuites[tridx].Info, fmt.Sprintf(format, a...))
+
+}
+
+func readStats(statFn string) (*TestRun, error) {
+	// Check if the  stats file exists
+	if _,err := os.Stat(statFn); err != nil {
+		// Nothing to do, just return
+		return &TestRun{}, nil
+	}
+	rtrn := &TestRun{}
+	// The file is there, read it an unmarshal it into the stats struct
+	if statBytes, err := ioutil.ReadFile(statFn); err != nil {
+		log.Error(err)
+		return nil, err
+	} else if err := json.Unmarshal(statBytes, rtrn); err != nil {
+		log.Error(err)
+		return nil, err
+	}
+	return rtrn, nil
+}
+
+func writeStats(statFn string, stats * TestRun) error {
+	// Check if the  stats file exists
+	// The file is there, read it an unmarshal it into the stats struct
+	if statBytes, err := json.MarshalIndent(stats, "","    "); err != nil {
+		log.Error(err)
+		return err
+	} else if err := ioutil.WriteFile(statFn+".new", statBytes, 0644); err != nil {
+		log.Error(err)
+		return err
+	}
+	if err := os.Rename(statFn, statFn+"~"); err != nil {
+		log.Error(err)
+		return err
+	}
+	if err := os.Rename(statFn+".new", statFn); err != nil {
+		log.Error(err)
+		return err
+	}
+	return nil
+}
+
+func (tr * TestRun) appendNew() {
+	tr.TestSuites = append(tr.TestSuites, TestSuite{})
+}
+
+func initStats(statFn string) error {
+	s := &TestRun{}
+
+	if statBytes, err := json.MarshalIndent(s, "","    "); err != nil {
+		log.Error(err)
+		return err
+	} else if err := ioutil.WriteFile(statFn, statBytes, 0644); err != nil {
+		log.Error(err)
+		return err
+	}
+
+	return nil
+}
+
+
+var statFn string
+var stats *TestRun
diff --git a/tests/afrouter/tester.go b/tests/afrouter/tester.go
index f3d975e..fafbbbe 100644
--- a/tests/afrouter/tester.go
+++ b/tests/afrouter/tester.go
@@ -22,8 +22,10 @@
 	"fmt"
 	"flag"
 	"path"
+	"math"
 	//"bufio"
 	"errors"
+	"regexp"
 	"os/exec"
 	"strconv"
 	"io/ioutil"
@@ -34,6 +36,8 @@
 	pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )
 
+const MAX_CT = 500
+
 type TestConfig struct {
 	configFile *string
 	logLevel *int
@@ -47,6 +51,11 @@
 	Port string `json:"port"`
 }
 
+type EndpointList struct {
+	Imports []string `json:"imports"`
+	Endpoints []Connection `json:"endPoints"`
+}
+
 type ProtoFile struct {
 	ImportPath string `json:"importPath"`
 	Service string `json:"service"`
@@ -62,8 +71,8 @@
 	Command string `json:"cmdLine"`
 	ProtoFiles []ProtoFile `json:"protoFiles"`
 	ProtoDesc string `json:"protoDesc"`
-	Clients []Connection `json:"clients"`
-	Servers []Connection `json:"servers"`
+	Clients EndpointList `json:"clients"`
+	Servers EndpointList `json:"servers"`
 	Imports []string `json:"imports"`
 	ProtoSubsts []ProtoSubst `json:"protoSubst"`
 }
@@ -89,6 +98,7 @@
 
 type Test struct {
 	Name string `json:"name"`
+	InfoOnly bool `json:"infoOnly"`
 	Send Rpc `json:"send"`
 	Servers []Server `json:"servers"`
 }
@@ -102,6 +112,7 @@
 	Service string
 	Short string
 	Package string
+	Used bool
 }
 
 type SendItem struct {
@@ -117,14 +128,32 @@
 
 type TestCase struct {
 	Name string
+	InfoOnly bool
 	Send SendItem
 	Srvr []Server
 }
 
+type MethodTypes struct {
+	ParamType string
+	ReturnType string
+	CodeGenerated bool
+}
+
+type Import struct {
+	Package string
+	Used bool
+}
+
 type TestList struct {
 	ProtoImports []ProtoImport
-	Imports []string
+	Imports []Import
 	Tests []TestCase
+	Funcs map[string]MethodTypes
+	RunTestsCallList []string
+	FileNum int
+	//NextFile int
+	HasFuncs bool
+	Offset int
 }
 
 type ClientConfig struct {
@@ -309,16 +338,19 @@
 						t *template.Template) error {
 	var servers []ServerConfig
 
-	for k,v := range ts.Env.Servers {
+	for k,v := range ts.Env.Servers.Endpoints {
 		log.Infof("Generating the code for server[%d]: %s", k, v.Name)
-		sc := &ServerConfig{Name:v.Name, Port:v.Port, Ct:k, Imports:ts.Env.Imports}
+		sc := &ServerConfig{Name:v.Name, Port:v.Port, Ct:k, Imports:ts.Env.Servers.Imports,
+							Methods:make(map[string]*mthd)}
 		for k1,v1 := range ts.Env.ProtoFiles {
 			imp := &ProtoImport{Short:"pb"+strconv.Itoa(k1),
 								Package:v1.ImportPath+v1.Package,
-								Service:v1.Service}
+								Service:v1.Service,
+								Used:true}
 			imp = &ProtoImport{Short:v1.Package,
 								Package:v1.ImportPath+v1.Package,
-								Service:v1.Service}
+								Service:v1.Service,
+								Used:true}
 			sc.ProtoImports = append(sc.ProtoImports, *imp)
 			// Compile the template from the file
 			log.Debugf("Proto substs: %v", ts.Env.ProtoSubsts)
@@ -329,7 +361,10 @@
 				return err
 			} else {
 				//Generate all the function calls required by the 
-				sc.Methods = mthds
+				for k,v := range mthds {
+					sc.Methods[k] = v
+				}
+				//sc.Methods = mthds
 			}
 		}
 		log.Debugf("Server: %v", *sc)
@@ -361,12 +396,10 @@
 func generateClients(conf *TestConfig, suiteDir string, ts * TestSuite,
 						t *template.Template) error {
 	var clients []ClientConfig
-	for k,v := range ts.Env.Clients {
+	for k,v := range ts.Env.Clients.Endpoints {
 		log.Infof("Generating the code for client[%d]: %s", k, v.Name)
-		cc := &ClientConfig{Name:v.Name, Port:v.Port, Ct:k, Imports:ts.Env.Imports}
-		// TODO: This loop makes no sense, the only proto map that would remain
-		// after this loop is the last one loaded. Fix this to load the map
-		// for all services not just the last one.
+		cc := &ClientConfig{Name:v.Name, Port:v.Port, Ct:k, Imports:ts.Env.Clients.Imports,
+							Methods:make(map[string]*mthd)}
 		for _,v1 := range ts.Env.ProtoFiles {
 			imp := &ProtoImport{Short:v1.Package,
 								Package:v1.ImportPath+v1.Package,
@@ -380,12 +413,14 @@
 						ts.Env.ProtoDesc, v1.Package, v1.Service)
 				return err
 			} else {
-				//Generate all the function calls required by the 
-				cc.Methods = mthds
+				// Add to the known methods
+				for k,v := range mthds {
+					cc.Methods[k] = v
+				}
 			}
 		}
 		clients = append(clients, *cc)
-		if f,err := os.Create(suiteDir+"/"+v.Name+".go"); err == nil {
+		if f,err := os.Create(suiteDir+"/"+v.Name+"_client.go"); err == nil {
 			_=f
 			defer f.Close()
 			if err := t.ExecuteTemplate(f, "client.go", cc); err != nil {
@@ -393,7 +428,7 @@
 				return err
 			}
 		} else {
-			log.Errorf("Couldn't create file %s : %v", suiteDir+"/client.go", err)
+			log.Errorf("Couldn't create file %s : %v", suiteDir+"/"+v.Name+"_client.go", err)
 			return err
 		}
 	}
@@ -409,28 +444,117 @@
 }
 
 func serverExists(srvr string, ts * TestSuite) bool {
-	for _,v := range ts.Env.Servers {
+	for _,v := range ts.Env.Servers.Endpoints {
 		if v.Name == srvr {
 			return true
 		}
 	}
 	return false
 }
+
+func getPackageList(tests []TestCase) map[string]struct{} {
+	var rtrn map[string]struct{} = make(map[string]struct{})
+	var p string
+	var e string
+	r := regexp.MustCompile(`^([^.]+)\..*$`)
+	for _,v := range tests {
+		pa := r.FindStringSubmatch(v.Send.ParamType)
+		if len(pa) == 2 {
+			p = pa[1]
+		} else {
+			log.Errorf("Internal error regexp returned %v", pa)
+		}
+		ea := r.FindStringSubmatch(v.Send.ExpectType)
+		if len(ea) == 2 {
+			e = ea[1]
+		} else {
+			log.Errorf("Internal error regexp returned %v", pa)
+		}
+		if _,ok := rtrn[p]; ok == false {
+			rtrn[p] = struct{}{}
+		}
+		if _,ok := rtrn[e]; ok == false {
+			rtrn[e] = struct{}{}
+		}
+	}
+	return rtrn
+}
+
+func fixupProtoImports(protoImports []ProtoImport, used map[string]struct{}) []ProtoImport {
+	var rtrn []ProtoImport
+	//log.Infof("Updating imports %v, using %v", protoImports, used)
+	for _,v := range protoImports {
+		//log.Infof("Looking for package %s", v.Package)
+		if _,ok := used[v.Short]; ok == true {
+			rtrn = append(rtrn, ProtoImport {
+				Service: v.Service,
+				Short: v.Short,
+				Package: v.Package,
+				Used: true,
+			})
+		} else {
+			rtrn = append(rtrn, ProtoImport {
+				Service: v.Service,
+				Short: v.Short,
+				Package: v.Package,
+				Used: false,
+			})
+		}
+	}
+	//log.Infof("After update %v", rtrn)
+	return rtrn
+}
+
+func fixupImports(imports []Import, used map[string]struct{}) []Import {
+	var rtrn []Import
+	var p string
+	re := regexp.MustCompile(`^.*/([^/]+)$`)
+	//log.Infof("Updating imports %v, using %v", protoImports, used)
+	for _,v := range imports {
+		//log.Infof("Looking for match in %s", v.Package)
+		pa := re.FindStringSubmatch(v.Package)
+		if len(pa) == 2 {
+			p = pa[1]
+		} else {
+			log.Errorf("Substring match failed, regexp returned %v", pa)
+		}
+		//log.Infof("Looking for package %s", v.Package)
+		if _,ok := used[p]; ok == true {
+			rtrn = append(rtrn, Import {
+				Package: v.Package,
+				Used: true,
+			})
+		} else {
+			rtrn = append(rtrn, Import {
+				Package: v.Package,
+				Used: false,
+			})
+		}
+	}
+	//log.Infof("After update %v", rtrn)
+	return rtrn
+}
+
+
 func generateTestCases(conf *TestConfig, suiteDir string, ts * TestSuite,
 						t *template.Template) error {
 	var mthdMap map[string]*mthd
+	mthdMap = make(map[string]*mthd)
 	// Generate the test cases
 	log.Info("Generating the test cases: runTests.go")
-	tc := &TestList{Imports:ts.Env.Imports}
+	tc := &TestList{Funcs:make(map[string]MethodTypes),
+					FileNum:0, HasFuncs: false,
+					Offset:0}
+	for _,v := range ts.Env.Imports {
+		tc.Imports = append(tc.Imports,Import{Package:v, Used:true})
+	}
 
 	// Load the proto descriptor file
-	// TODO: This loop makes no sense, the only proto map that would remain
-	// after this loop is the last one loaded. Fix this to load the map
-	// for all services not just the last one.
 	for _,v := range ts.Env.ProtoFiles {
 		imp := &ProtoImport{Short:v.Package,
 							Package:v.ImportPath+v.Package,
-							Service:v.Service}
+							Service:v.Service,
+							Used:true}
 		tc.ProtoImports = append(tc.ProtoImports, *imp)
 		// Compile the template from the file
 		log.Debugf("Proto substs: %v", ts.Env.ProtoSubsts)
@@ -440,14 +564,59 @@
 					ts.Env.ProtoDesc, v.Package, v.Service)
 			return err
 		} else {
-			mthdMap = mthds
+			// Add to the known methods
+			for k,v := range mthds {
+				mthdMap[k] = v
+			}
 		}
 	}
+	// Since the input file can possibly be a template with loops that
+	// make multiple calls to exactly the same method with potentially
+	// different parameters it is best to try to optimize for that case.
+	// Creating a function for each method used will greatly reduce the
+	// code size and repetition. In the case where a method is used only
+	// once the resulting code will be bigger but this is an acceptable
+	// tradeoff to allow huge suites that call the same method repeatedly
+	// to test for leaks.
+
+	// The go compiler has trouble compiling files that are too large. In order
+	// to mitigate that, It's necessary to create more smaller files than the
+	// single one large one while making sure that the functions for the distinct
+	// methods are only defined once in one of the files.
+
+	// Yet another hiccup with the go compiler, it doesn't like deep function
+	// nesting meaning that each runTests function can't call the next without
+	// eventually blowing the stack check. In order to work around this, the
+	// first runTests function needs to call all the others in sequence to
+	// keep the stack depth constant.
+
+	// Counter limiting the number of tests to output to each file
+	maxCt := MAX_CT
+
+	// Get the list of distinct methods
+	//for _,v := range ts.Tests {
+	//	if _,ok := tc.Funcs[v.Send.Method]; ok == false {
+	//		tc.Funcs[v.Send.Method] = MethodTypes{ParamType:mthdMap[v.Send.Method].Param,
+	//											  ReturnType:mthdMap[v.Send.Method].Rtrn}
+	//	}
+	//}
+	for i:=1; i<int(math.Ceil(float64(len(ts.Tests))/float64(MAX_CT))); i++ {
+		tc.RunTestsCallList = append(tc.RunTestsCallList, "runTests"+strconv.Itoa(i))
+	}
+
 	// Create the test data structure for the template
 	for _,v := range ts.Tests {
 		var test TestCase
 
+		if _,ok := tc.Funcs[v.Send.Method]; ok == false {
+			tc.Funcs[v.Send.Method] = MethodTypes{ParamType:mthdMap[v.Send.Method].Param,
+												  ReturnType:mthdMap[v.Send.Method].Rtrn,
+												  CodeGenerated:false}
+			tc.HasFuncs = true
+		}
+
 		test.Name = v.Name
+		test.InfoOnly = v.InfoOnly
 		test.Send.Client = v.Send.Client
 		test.Send.Method = v.Send.Method
 		test.Send.Param = v.Send.Param
@@ -471,15 +640,63 @@
 			test.Srvr = append(test.Srvr, srvr)
 		}
 		tc.Tests = append(tc.Tests, test)
+		if maxCt--; maxCt == 0 {
+			// Get the list of proto pacakges required for this file
+			pkgs := getPackageList(tc.Tests)
+			// Adjust the proto import data accordingly
+			tc.ProtoImports = fixupProtoImports(tc.ProtoImports, pkgs)
+			tc.Imports = fixupImports(tc.Imports, pkgs)
+			//log.Infof("The packages needed are: %v", pkgs)
+			if f,err := os.Create(suiteDir+"/runTests"+strconv.Itoa(tc.FileNum)+".go"); err == nil {
+				if err := t.ExecuteTemplate(f, "runTests.go", tc); err != nil {
+						log.Errorf("Unable to execute template for runTests.go: %v", err)
+				}
+				f.Close()
+			} else {
+				log.Errorf("Couldn't create file %s : %v",
+						suiteDir+"/runTests"+strconv.Itoa(tc.FileNum)+".go", err)
+			}
+			tc.FileNum++
+			//tc.NextFile++
+			maxCt = MAX_CT
+			// Mark the functions as generated.
+			tc.Tests = []TestCase{}
+			for k,v := range tc.Funcs {
+				tc.Funcs[k] = MethodTypes{ParamType:v.ParamType,
+										 ReturnType:v.ReturnType,
+										 CodeGenerated:true}
+			}
+			tc.HasFuncs = false
+			tc.Offset += MAX_CT
+			//tmp,_ := strconv.Atoi(tc.Offset)
+			//tc.Offset = strconv.Itoa(tmp+500)
+		}
 	}
-	if f,err := os.Create(suiteDir+"/runTests.go"); err == nil {
+	//tc.NextFile = 0
+	// Get the list of proto pacakges required for this file
+	pkgs := getPackageList(tc.Tests)
+	// Adjust the proto import data accordingly
+	tc.ProtoImports = fixupProtoImports(tc.ProtoImports, pkgs)
+	tc.Imports = fixupImports(tc.Imports, pkgs)
+	//log.Infof("The packages needed are: %v", pkgs)
+	if f,err := os.Create(suiteDir+"/runTests"+strconv.Itoa(tc.FileNum)+".go"); err == nil {
 		if err := t.ExecuteTemplate(f, "runTests.go", tc); err != nil {
 				log.Errorf("Unable to execute template for runTests.go: %v", err)
 		}
 		f.Close()
 	} else {
-		log.Errorf("Couldn't create file %s : %v", suiteDir+"/runTests.go", err)
+		log.Errorf("Couldn't create file %s : %v",
+				suiteDir+"/runTests"+strconv.Itoa(tc.FileNum)+".go", err)
 	}
+
+	//if f,err := os.Create(suiteDir+"/runTests.go"); err == nil {
+	//	if err := t.ExecuteTemplate(f, "runTests.go", tc); err != nil {
+	//			log.Errorf("Unable to execute template for runTests.go: %v", err)
+	//	}
+	//	f.Close()
+	//} else {
+	//	log.Errorf("Couldn't create file %s : %v", suiteDir+"/runTests.go", err)
+	//}
 	return nil
 }
 
@@ -497,13 +714,14 @@
 		ts := &TestSuite{}
 		ts.loadSuite(v)
 		log.Debugf("Suite %s: %v", v, ts)
-		log.Info("Processing test suite %s", v)
+		log.Infof("Processing test suite %s", v)
 
 		t := template.Must(template.New("").ParseFiles("../templates/server.go",
 														"../templates/serverInit.go",
 														"../templates/client.go",
 														"../templates/clientInit.go",
 														"../templates/runTests.go",
+														"../templates/stats.go",
 														"../templates/main.go"))
 		// Create a directory for he source code for this test suite
 		if err := os.Mkdir(suiteDir, 0777); err != nil {
@@ -537,6 +755,17 @@
 			log.Errorf("Couldn't create file %s : %v", suiteDir+"/main.go", err)
 		}
 
+		log.Infof("Copying over common modules")
+		if f,err := os.Create(suiteDir+"/stats.go"); err == nil {
+			if err := t.ExecuteTemplate(f, "stats.go", ts.Env); err != nil {
+					log.Errorf("Unable to execute template for stats.go: %v", err)
+			}
+			f.Close()
+		} else {
+			log.Errorf("Couldn't create file %s : %v", suiteDir+"/stats.go", err)
+		}
+
+
 		log.Infof("Compiling test suite: %s in directory %s", v, suiteDir)
 		if err := os.Chdir(suiteDir); err != nil {
 			log.Errorf("Could not change to directory '%s':%v",suiteDir, err)
@@ -562,15 +791,24 @@
 		log.Errorf("Unable to create directory 'driver':%v\n", err)
 		return err
 	}
-	t := template.Must(template.New("").ParseFiles("../templates/runAll.go"))
+	t := template.Must(template.New("").ParseFiles("../templates/runAll.go",
+					"../templates/stats.go"))
 	if f,err := os.Create(srcDir+"/runAll.go"); err == nil {
 		if err := t.ExecuteTemplate(f, "runAll.go", conf.Suites); err != nil {
-				log.Errorf("Unable to execute template for main.go: %v", err)
+				log.Errorf("Unable to execute template for runAll.go: %v", err)
 		}
 		f.Close()
 	} else {
 		log.Errorf("Couldn't create file %s : %v", srcDir+"/runAll.go", err)
 	}
+	if f,err := os.Create(srcDir+"/stats.go"); err == nil {
+		if err := t.ExecuteTemplate(f, "stats.go", conf.Suites); err != nil {
+				log.Errorf("Unable to execute template for stats.go: %v", err)
+		}
+		f.Close()
+	} else {
+		log.Errorf("Couldn't create file %s : %v", srcDir+"/stats.go", err)
+	}
 
 	// Compile the test driver file
 	log.Info("Compiling the test driver")