Added unit annotation supports onto tsmon in go.

common/tsmon/monitor/acq_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package monitor
 
 import (
         "fmt"
         "math"
         "testing"
@@ skipping 119 matching lines @@
 
 func TestSerializeCell(t *testing.T) {
         Convey("Int", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.NonCumulativeIntType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     int64(42),
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         Task:             &pb.Task{},
                         Gauge:            proto.Int64(42),
                 })
         })
 
         Convey("Counter", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.CumulativeIntType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     int64(42),
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         StartTimestampUs: proto.Uint64(946782245000000),
                         Task:             &pb.Task{},
                         Counter:          proto.Int64(42),
                 })
         })
 
         Convey("Float", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.NonCumulativeFloatType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     float64(42),
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         Task:             &pb.Task{},
                         NoncumulativeDoubleValue: proto.Float64(42),
                 })
         })
 
         Convey("FloatCounter", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.CumulativeFloatType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     float64(42),
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         StartTimestampUs: proto.Uint64(946782245000000),
                         Task:             &pb.Task{},
                         CumulativeDoubleValue: proto.Float64(42),
                 })
         })
 
         Convey("String", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.StringType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     "hello",
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         Task:             &pb.Task{},
                         StringValue:      proto.String("hello"),
                 })
         })
 
         Convey("Boolean", t, func() {
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.BoolType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target.Task{},
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     true,
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
@@ skipping 10 matching lines @@
                         JobName:     proto.String("world"),
                 }
 
                 ret := SerializeCell(types.Cell{
                         types.MetricInfo{
                                 Name:        "foo",
                                 Description: "bar",
                                 Fields:      []field.Field{},
                                 ValueType:   types.NonCumulativeIntType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 Target:    &target,
                                 ResetTime: time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC),
                                 Value:     int64(42),
                         },
                 })
                 So(ret, ShouldResemble, &pb.MetricsData{
                         Name:             proto.String("foo"),
                         Description:      proto.String("bar"),
                         MetricNamePrefix: proto.String("/chrome/infra/"),
                         Fields:           []*pb.MetricsField{},
                         Task: &pb.Task{
                                 ServiceName: proto.String("hello"),
                                 JobName:     proto.String("world"),
                         },
                         Gauge: proto.Int64(42),
                 })
         })
 }