Added unit annotation supports onto tsmon in go.

common/tsmon/flush_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 tsmon
 
 import (
         "testing"
         "time"
 
@@ skipping 20 matching lines @@
 
         Convey("Sends a metric", t, func() {
                 c, s, m := WithFakes(c)
                 s.Cells = []types.Cell{
                         {
                                 types.MetricInfo{
                                         Name:      "foo",
                                         Fields:    []field.Field{},
                                         ValueType: types.StringType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: []interface{}{},
                                         ResetTime: time.Unix(1234, 1000),
                                         Value:     "bar",
                                 },
                         },
                 }
                 s.DT = defaultTarget
                 m.CS = 42
 
                 So(Flush(c), ShouldBeNil)
 
                 So(len(m.Cells), ShouldEqual, 1)
                 So(len(m.Cells[0]), ShouldEqual, 1)
                 So(m.Cells[0][0], ShouldResemble, types.Cell{
                         types.MetricInfo{
                                 Name:      "foo",
                                 Fields:    []field.Field{},
                                 ValueType: types.StringType,
                         },
+                        types.MetricMetadata{},
                         types.CellData{
                                 FieldVals: []interface{}{},
                                 ResetTime: time.Unix(1234, 1000),
                                 Value:     "bar",
                         },
                 })
         })
 
         Convey("Splits up ChunkSize metrics", t, func() {
                 c, s, m := WithFakes(c)
                 s.Cells = make([]types.Cell, 43)
                 s.DT = defaultTarget
                 m.CS = 42
 
                 for i := 0; i < 43; i++ {
                         s.Cells[i] = types.Cell{
                                 types.MetricInfo{
                                         Name:      "foo",
                                         Fields:    []field.Field{},
                                         ValueType: types.StringType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: []interface{}{},
                                         ResetTime: time.Unix(1234, 1000),
                                         Value:     "bar",
                                 },
                         }
                 }
 
                 So(Flush(c), ShouldBeNil)
 
                 So(len(m.Cells), ShouldEqual, 2)
                 So(len(m.Cells[0]), ShouldEqual, 42)
                 So(len(m.Cells[1]), ShouldEqual, 1)
         })
 
         Convey("Doesn't split metrics when ChunkSize is 0", t, func() {
                 c, s, m := WithFakes(c)
                 s.Cells = make([]types.Cell, 43)
                 s.DT = defaultTarget
                 m.CS = 0
 
                 for i := 0; i < 43; i++ {
                         s.Cells[i] = types.Cell{
                                 types.MetricInfo{
                                         Name:      "foo",
                                         Fields:    []field.Field{},
                                         ValueType: types.StringType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: []interface{}{},
                                         ResetTime: time.Unix(1234, 1000),
                                         Value:     "bar",
                                 },
                         }
                 }
 
                 So(Flush(c), ShouldBeNil)
 
@@ skipping 32 matching lines @@
                 // Each 'flush' gets blocked on sending into 'moments'. Once unblocked, it
                 // advances timer by 'interval' sec (1 sec in the test).
                 So(<-moments, ShouldEqual, 1)
                 So(<-moments, ShouldEqual, 2)
                 // and so on ...
 
                 // Doesn't timeout => works.
                 flusher.stop()
         })
 }