Migrate tsmon protos to proto3

common/tsmon/store/testing.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package store
 
 import (
         "bytes"
         "fmt"
         "sort"
@@ skipping 244 matching lines @@
                                                 test.wantSetValidator(v, test.values[0])
                                         } else {
                                                 So(v, ShouldEqual, test.values[0])
                                         }
 
                                         // Check the time in the Cell is the same.
                                         all := s.GetAll(ctx)
                                         So(len(all), ShouldEqual, 1)
 
                                         msg := monitor.SerializeCell(all[0])
-                                        So(time.Unix(0, int64(msg.GetStartTimestampUs()*uint64(time.Microsecond))).UTC().String(),
+                                        So(time.Unix(0, int64(msg.StartTimestampUs*uint64(time.Microsecond))).UTC().String(),
                                                 ShouldEqual, t.String())
                                 })
                         }
                 })
 
                 Convey("With a target set in the context", func() {
                         for i, test := range tests {
                                 if !test.wantSetSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
                                                 m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
                                         } else {
                                                 m = &FakeMetric{"m", "", []field.Field{}, test.typ}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Create a context with a different target.
                                         t := target.Task{}
-                                        t.AsProto().ServiceName = proto.String("foo")
+                                        t.AsProto().ServiceName = "foo"
                                         ctxWithTarget := target.Set(ctx, &t)
 
                                         // Set the first value on the default target, second value on the
                                         // different target.
                                         So(s.Set(ctx, m, time.Time{}, []interface{}{}, test.values[0]), ShouldBeNil)
                                         So(s.Set(ctxWithTarget, m, time.Time{}, []interface{}{}, test.values[1]), ShouldBeNil)
 
                                         // Get should return different values for different contexts.
                                         v, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                                         So(err, ShouldBeNil)
@@ skipping 10 matching lines @@
                                         } else {
                                                 So(v, ShouldEqual, test.values[1])
                                         }
 
                                         // The targets should be set in the Cells.
                                         all := s.GetAll(ctx)
                                         So(len(all), ShouldEqual, 2)
 
                                         coll := monitor.SerializeCells(all)
                                         sort.Sort(sortableDataSlice(coll.Data))
-                                        So(coll.Data[0].Task.GetServiceName(), ShouldEqual,
-                                                s.DefaultTarget().(*target.Task).AsProto().GetServiceName())
-                                        So(coll.Data[1].Task.GetServiceName(), ShouldEqual, t.AsProto().GetServiceName())
+                                        So(coll.Data[0].Task.ServiceName, ShouldEqual,
+                                                s.DefaultTarget().(*target.Task).AsProto().ServiceName)
+                                        So(coll.Data[1].Task.ServiceName, ShouldEqual, t.AsProto().ServiceName)
                                 })
                         }
                 })
 
                 Convey("With a decreasing value", func() {
                         for i, test := range tests {
                                 if !test.typ.IsCumulative() || test.bucketer != nil {
                                         continue
                                 }
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
@@ skipping 124 matching lines @@
 
                                         // Do the incr with a fixed time.
                                         t := time.Date(1972, 5, 6, 7, 8, 9, 0, time.UTC)
                                         So(s.Incr(ctx, m, t, []interface{}{}, test.deltas[0]), ShouldBeNil)
 
                                         // Check the time in the Cell is the same.
                                         all := s.GetAll(ctx)
                                         So(len(all), ShouldEqual, 1)
 
                                         msg := monitor.SerializeCell(all[0])
-                                        So(time.Unix(0, int64(msg.GetStartTimestampUs()*uint64(time.Microsecond))).UTC().String(),
+                                        So(time.Unix(0, int64(msg.StartTimestampUs*uint64(time.Microsecond))).UTC().String(),
                                                 ShouldEqual, t.String())
                                 })
                         }
                 })
 
                 Convey("With a target set in the context", func() {
                         for i, test := range tests {
                                 if !test.wantIncrSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
                                                 m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
                                         } else {
                                                 m = &FakeMetric{"m", "", []field.Field{}, test.typ}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Create a context with a different target.
                                         t := target.Task{}
-                                        t.AsProto().ServiceName = proto.String("foo")
+                                        t.AsProto().ServiceName = "foo"
                                         ctxWithTarget := target.Set(ctx, &t)
 
                                         // Incr the first delta on the default target, second delta on the
                                         // different target.
                                         So(s.Incr(ctx, m, time.Time{}, []interface{}{}, test.deltas[0]), ShouldBeNil)
                                         So(s.Incr(ctxWithTarget, m, time.Time{}, []interface{}{}, test.deltas[1]), ShouldBeNil)
 
                                         // Get should return different values for different contexts.
                                         v1, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                                         So(err, ShouldBeNil)
                                         v2, err := s.Get(ctxWithTarget, m, time.Time{}, []interface{}{})
                                         So(err, ShouldBeNil)
                                         So(v1, ShouldNotEqual, v2)
 
                                         // The targets should be set in the Cells.
                                         all := s.GetAll(ctx)
                                         So(len(all), ShouldEqual, 2)
 
                                         coll := monitor.SerializeCells(all)
                                         sort.Sort(sortableDataSlice(coll.Data))
-                                        So(coll.Data[0].Task.GetServiceName(), ShouldEqual,
-                                                s.DefaultTarget().(*target.Task).AsProto().GetServiceName())
-                                        So(coll.Data[1].Task.GetServiceName(), ShouldEqual, t.AsProto().GetServiceName())
+                                        So(coll.Data[0].Task.ServiceName, ShouldEqual,
+                                                s.DefaultTarget().(*target.Task).AsProto().ServiceName)
+                                        So(coll.Data[1].Task.ServiceName, ShouldEqual, t.AsProto().ServiceName)
                                 })
                         }
                 })
         })
 
         Convey("GetAll", t, func() {
                 ctx, tc := testclock.UseTime(context.Background(), testclock.TestTimeLocal)
 
                 s := opts.Factory()
                 foo := &FakeMetric{"foo", "", []field.Field{}, types.NonCumulativeIntType}
@@ skipping 125 matching lines @@
         })
 
         Convey("Different targets", t, func() {
                 Convey("Gets from context", func() {
                         s := opts.Factory()
                         m := &FakeMetric{"m", "", []field.Field{}, types.NonCumulativeIntType}
                         s.Register(m)
                         opts.RegistrationFinished(s)
 
                         t := target.Task{}
-                        t.AsProto().ServiceName = proto.String("foo")
+                        t.AsProto().ServiceName = "foo"
                         ctxWithTarget := target.Set(ctx, &t)
 
                         So(s.Set(ctx, m, time.Time{}, []interface{}{}, int64(42)), ShouldBeNil)
                         So(s.Set(ctxWithTarget, m, time.Time{}, []interface{}{}, int64(43)), ShouldBeNil)
 
                         val, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, 42)
 
                         val, err = s.Get(ctxWithTarget, m, time.Time{}, []interface{}{})
@@ skipping 46 matching lines @@
 
 type sortableDataSlice []*pb.MetricsData
 
 func (s sortableDataSlice) Len() int { return len(s) }
 func (s sortableDataSlice) Less(i, j int) bool {
         a, _ := proto.Marshal(s[i])
         b, _ := proto.Marshal(s[j])
         return bytes.Compare(a, b) > 0
 }
 func (s sortableDataSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }