2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
26 func TestMetricCounter(t *testing.T) {
27 TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"}
28 ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
30 ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
33 t.Errorf("ret1 not same than ret2. cache not working?")
37 func TestMetricCounterGroup(t *testing.T) {
38 var TestCounterOpts = []CounterOpts{
39 {Name: "CounterBlaah1", Help: "CounterBlaah1"},
40 {Name: "CounterBlaah2", Help: "CounterBlaah2"},
41 {Name: "CounterBlaah3", Help: "CounterBlaah3"},
42 {Name: "CounterBlaah4", Help: "CounterBlaah4"},
45 ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
48 t.Errorf("ret1 counter group is empty")
51 ret1["CounterBlaah1"].Inc()
52 ret1["CounterBlaah2"].Inc()
53 ret1["CounterBlaah3"].Inc()
54 ret1["CounterBlaah4"].Inc()
56 ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
59 t.Errorf("ret2 counter group is empty")
62 ret2["CounterBlaah1"].Inc()
63 ret2["CounterBlaah2"].Inc()
64 ret2["CounterBlaah3"].Inc()
65 ret2["CounterBlaah4"].Inc()
67 if len(ret1) != len(ret2) {
68 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
72 func TestMetricLabeledCounter(t *testing.T) {
75 c_1_1 := Metric.RegisterLabeledCounter(
76 CounterOpts{Name: "counter1", Help: "counter1"},
77 []string{"name", "event"},
78 []string{"name1", "event1"},
81 c_1_2 := Metric.RegisterLabeledCounter(
82 CounterOpts{Name: "counter1", Help: "counter1"},
83 []string{"name", "event"},
84 []string{"name1", "event1"},
90 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
95 c_2_1 := Metric.RegisterLabeledCounter(
96 CounterOpts{Name: "counter1", Help: "counter1"},
97 []string{"name", "event"},
98 []string{"name1", "event2"},
101 c_2_2 := Metric.RegisterLabeledCounter(
102 CounterOpts{Name: "counter1", Help: "counter1"},
103 []string{"name", "event"},
104 []string{"name1", "event2"},
110 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
114 t.Errorf("c_1_1 same than c_2_1. what?")
117 t.Errorf("c_1_2 same than c_2_2. what?")
122 func TestMetricLabeledCounterMissmatch(t *testing.T) {
123 Metric.RegisterLabeledCounter(
124 CounterOpts{Name: "counter1", Help: "counter1"},
125 []string{"name", "event"},
126 []string{"name1", "event1"},
127 "SUBSYSTEMLERRMISSMATCH")
129 ret := Metric.RegisterLabeledCounter(
130 CounterOpts{Name: "counter1", Help: "counter1"},
131 []string{"name", "eventmiss"},
132 []string{"name1", "event1"},
133 "SUBSYSTEMLERRMISSMATCH")
136 t.Errorf("Returned counter even its labels are mismatching")
139 ret = Metric.RegisterLabeledCounter(
140 CounterOpts{Name: "counter1", Help: "counter1"},
143 "SUBSYSTEMLERRMISSMATCH")
146 t.Errorf("Returned counter even its labels are mismatching")
151 func TestMetricLabeledCounterWrongOrder(t *testing.T) {
152 Metric.RegisterLabeledCounter(
153 CounterOpts{Name: "counter1", Help: "counter1"},
154 []string{"name", "event"},
155 []string{"name1", "event1"},
156 "SUBSYSTEMLERRWRONGORDER")
158 ret := Metric.RegisterLabeledCounter(
159 CounterOpts{Name: "counter1", Help: "counter1"},
160 []string{"event", "name"},
161 []string{"name1", "event1"},
162 "SUBSYSTEMLERRWRONGORDER")
165 t.Errorf("Returned counter even its labels order is wrong")
169 func TestMetricLabeledCounterCounterNameExists(t *testing.T) {
170 Metric.RegisterCounter(
171 CounterOpts{Name: "counter1", Help: "counter1"},
172 "SUBSYSTEMLERRNAMEEXISTS")
174 ret := Metric.RegisterLabeledCounter(
175 CounterOpts{Name: "counter1", Help: "counter1"},
176 []string{"name", "event"},
177 []string{"name1", "event1"},
178 "SUBSYSTEMLERRNAMEEXISTS")
181 t.Errorf("Returned labeled counter even its name conflicts with existing counter name")
185 func TestMetricCounterLabeledCounterNameExists(t *testing.T) {
186 Metric.RegisterLabeledCounter(
187 CounterOpts{Name: "counter2", Help: "counter2"},
188 []string{"name", "event"},
189 []string{"name1", "event1"},
190 "SUBSYSTEMLERRNAMEEXISTS")
192 ret := Metric.RegisterCounter(
193 CounterOpts{Name: "counter2", Help: "counter2"},
194 "SUBSYSTEMLERRNAMEEXISTS")
197 t.Errorf("Returned counter even its name conflicts with existing labeled counter name")
201 func TestMetricLabeledCounterGroup(t *testing.T) {
204 c_grp1 := Metric.RegisterLabeledCounterGroup(
205 []CounterOpts{{Name: "counter1", Help: "counter1"}},
206 []string{"name", "event"},
207 []string{"name1", "event1"},
210 if _, ok := c_grp1["counter1"]; ok == false {
211 t.Errorf("c_grp1 counter1 not exists")
213 c_grp1["counter1"].Inc()
217 c_grp2 := Metric.RegisterLabeledCounterGroup(
218 []CounterOpts{{Name: "counter1", Help: "counter1"}},
219 []string{"name", "event"},
220 []string{"name1", "event2"},
223 if _, ok := c_grp2["counter1"]; ok == false {
224 t.Errorf("c_grp2 counter1 not exists")
226 c_grp2["counter1"].Inc()
229 func TestMetricGauge(t *testing.T) {
230 TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"}
231 ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
233 ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
236 t.Errorf("ret1 not same than ret2. cache not working?")
240 func TestMetricGaugeGroup(t *testing.T) {
241 var TestGaugeOpts = []CounterOpts{
242 {Name: "GaugeBlaah1", Help: "GaugeBlaah1"},
243 {Name: "GaugeBlaah2", Help: "GaugeBlaah2"},
244 {Name: "GaugeBlaah3", Help: "GaugeBlaah3"},
245 {Name: "GaugeBlaah4", Help: "GaugeBlaah4"},
248 ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
251 t.Errorf("ret1 gauge group is empty")
254 ret1["GaugeBlaah1"].Inc()
255 ret1["GaugeBlaah2"].Inc()
256 ret1["GaugeBlaah3"].Inc()
257 ret1["GaugeBlaah4"].Inc()
259 ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
262 t.Errorf("ret2 gauge group is empty")
265 ret2["GaugeBlaah1"].Inc()
266 ret2["GaugeBlaah2"].Inc()
267 ret2["GaugeBlaah3"].Inc()
268 ret2["GaugeBlaah4"].Inc()
270 if len(ret1) != len(ret2) {
271 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
275 func TestMetricLabeledGauge(t *testing.T) {
278 c_1_1 := Metric.RegisterLabeledGauge(
279 CounterOpts{Name: "gauge1", Help: "gauge1"},
280 []string{"name", "event"},
281 []string{"name1", "event1"},
284 c_1_2 := Metric.RegisterLabeledGauge(
285 CounterOpts{Name: "gauge1", Help: "gauge1"},
286 []string{"name", "event"},
287 []string{"name1", "event1"},
293 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
298 c_2_1 := Metric.RegisterLabeledGauge(
299 CounterOpts{Name: "gauge1", Help: "gauge1"},
300 []string{"name", "event"},
301 []string{"name1", "event2"},
304 c_2_2 := Metric.RegisterLabeledGauge(
305 CounterOpts{Name: "gauge1", Help: "gauge1"},
306 []string{"name", "event"},
307 []string{"name1", "event2"},
313 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
317 t.Errorf("c_1_1 same than c_2_1. what?")
320 t.Errorf("c_1_2 same than c_2_2. what?")
325 func TestMetricLabeledGaugeMissmatch(t *testing.T) {
326 Metric.RegisterLabeledGauge(
327 CounterOpts{Name: "gauge1", Help: "gauge1"},
328 []string{"name", "event"},
329 []string{"name1", "event1"},
330 "SUBSYSTEMLERRMISSMATCH")
332 ret := Metric.RegisterLabeledGauge(
333 CounterOpts{Name: "gauge1", Help: "gauge1"},
334 []string{"name", "eventmiss"},
335 []string{"name1", "event1"},
336 "SUBSYSTEMLERRMISSMATCH")
339 t.Errorf("Returned gauge even its labels are mismatching")
342 ret = Metric.RegisterLabeledGauge(
343 CounterOpts{Name: "gauge1", Help: "gauge1"},
346 "SUBSYSTEMLERRMISSMATCH")
349 t.Errorf("Returned gauge even its labels are mismatching")
354 func TestMetricLabeledGaugeWrongOrder(t *testing.T) {
355 Metric.RegisterLabeledGauge(
356 CounterOpts{Name: "gauge1", Help: "gauge1"},
357 []string{"name", "event"},
358 []string{"name1", "event1"},
359 "SUBSYSTEMLERRWRONGORDER")
361 ret := Metric.RegisterLabeledGauge(
362 CounterOpts{Name: "gauge1", Help: "gauge1"},
363 []string{"event", "name"},
364 []string{"name1", "event1"},
365 "SUBSYSTEMLERRWRONGORDER")
368 t.Errorf("Returned gauge even its labels order is wrong")
373 func TestMetricLabeledGaugeGaugeNameExists(t *testing.T) {
374 Metric.RegisterGauge(
375 CounterOpts{Name: "gauge1", Help: "gauge1"},
376 "SUBSYSTEMLERRNAMEEXISTS")
378 ret := Metric.RegisterLabeledGauge(
379 CounterOpts{Name: "gauge1", Help: "gauge1"},
380 []string{"name", "event"},
381 []string{"name1", "event1"},
382 "SUBSYSTEMLERRNAMEEXISTS")
385 t.Errorf("Returned labeled gauge even its name conflicts with existing gauge name")
389 func TestMetricGaugeLabeledGaugeNameExists(t *testing.T) {
390 Metric.RegisterLabeledGauge(
391 CounterOpts{Name: "gauge2", Help: "gauge2"},
392 []string{"name", "event"},
393 []string{"name1", "event1"},
394 "SUBSYSTEMLERRNAMEEXISTS")
396 ret := Metric.RegisterGauge(
397 CounterOpts{Name: "gauge2", Help: "gauge2"},
398 "SUBSYSTEMLERRNAMEEXISTS")
401 t.Errorf("Returned gauge even its name conflicts with existing labeled gauge name")
405 func TestMetricLabeledGaugeGroup(t *testing.T) {
408 g_grp1 := Metric.RegisterLabeledGaugeGroup(
409 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
410 []string{"name", "event"},
411 []string{"name1", "event1"},
414 if _, ok := g_grp1["gauge1"]; ok == false {
415 t.Errorf("g_grp1 gauge1 not exists")
417 g_grp1["gauge1"].Inc()
421 g_grp2 := Metric.RegisterLabeledGaugeGroup(
422 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
423 []string{"name", "event"},
424 []string{"name1", "event2"},
427 if _, ok := g_grp2["gauge1"]; ok == false {
428 t.Errorf("g_grp2 gauge1 not exists")
430 g_grp2["gauge1"].Inc()
433 func TestMetricGroupCache(t *testing.T) {
436 c_grp1 := Metric.RegisterLabeledCounterGroup(
437 []CounterOpts{{Name: "counter1", Help: "counter1"}},
438 []string{"name", "event"},
439 []string{"name1", "event1"},
441 if _, ok := c_grp1["counter1"]; ok == false {
442 t.Errorf("c_grp1 counter1 not exists")
444 c_grp1["counter1"].Inc()
448 c_grp2 := Metric.RegisterLabeledCounterGroup(
449 []CounterOpts{{Name: "counter1", Help: "counter1"}},
450 []string{"name", "event"},
451 []string{"name1", "event2"},
453 if _, ok := c_grp2["counter1"]; ok == false {
454 t.Errorf("c_grp2 counter1 not exists")
456 c_grp2["counter1"].Inc()
460 g_grp1 := Metric.RegisterLabeledGaugeGroup(
461 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
462 []string{"name", "event"},
463 []string{"name1", "event1"},
465 if _, ok := g_grp1["gauge1"]; ok == false {
466 t.Errorf("g_grp1 gauge1 not exists")
468 g_grp1["gauge1"].Inc()
472 g_grp2 := Metric.RegisterLabeledGaugeGroup(
473 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
474 []string{"name", "event"},
475 []string{"name1", "event2"},
477 if _, ok := g_grp2["gauge1"]; ok == false {
478 t.Errorf("g_grp2 gauge1 not exists")
480 g_grp2["gauge1"].Inc()
484 m_grp := NewMetricGroupsCache()
485 m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1)
486 m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2)
487 m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1)
488 m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2)
491 t.Errorf("Cache failed")
494 if m_grp.CIs("event1_counter1") == false {
495 t.Errorf("m_grp.Counters event1_counter1 not exists")
497 m_grp.CInc("event1_counter1")
499 if m_grp.CIs("event2_counter1") == false {
500 t.Errorf("m_grp.Counters event2_counter1 not exists")
502 m_grp.CInc("event2_counter1")
504 if m_grp.GIs("event1_gauge1") == false {
505 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
507 m_grp.GInc("event1_gauge1")
509 if m_grp.GIs("event2_gauge1") == false {
510 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
512 m_grp.GInc("event2_gauge1")
514 m_grp.CAdd("event2_counter1", 1)
515 m_grp.CGet("event2_counter1")
516 m_grp.GGet("event2_gauge1")
517 m_grp.GDec("event2_gauge1")
518 m_grp.GSet("event2_gauge1", 1)
521 type registerer struct{}
523 func (met *registerer) RegisterCounter(opts CounterOpts) Counter {
524 return Metric.RegisterLabeledCounter(
526 []string{"host", "interface"},
527 []string{"testhost", "testinterface"},
531 func (met *registerer) RegisterGauge(opts CounterOpts) Gauge {
532 return Metric.RegisterLabeledGauge(
534 []string{"host", "interface"},
535 []string{"testhost", "testinterface"},
539 func TestMetricCounterAutoCGetNoReg(t *testing.T) {
540 m_grp := NewMetricGroupsCache()
541 m_grp.CGet("cautotest1")
544 func TestMetricCounterAutoCGetFunc(t *testing.T) {
545 m_grp := NewMetricGroupsCache()
546 m_reg := ®isterer{}
547 m_grp.Registerer(MetricGroupsCacheCounterRegistererFunc(m_reg.RegisterCounter), nil)
548 m_grp.CGet("cautotest1")
551 func TestMetricCounterAutoCGet(t *testing.T) {
552 m_grp := NewMetricGroupsCacheWithRegisterers(®isterer{}, nil)
553 m_grp.CGet("cautotest1")
556 func TestMetricCounterAutoCInc(t *testing.T) {
557 m_grp := NewMetricGroupsCache()
558 m_grp.Registerer(®isterer{}, nil)
559 m_grp.CInc("cautotest1")
562 func TestMetricCounterAutoCAdd(t *testing.T) {
563 m_grp := NewMetricGroupsCache()
564 m_grp.Registerer(®isterer{}, nil)
565 m_grp.CAdd("cautotest1", float64(10))
568 func TestMetricCounterAutoGGetNoReg(t *testing.T) {
569 m_grp := NewMetricGroupsCache()
570 m_grp.GGet("gautotest1")
573 func TestMetricCounterAutoGGetFunc(t *testing.T) {
574 m_grp := NewMetricGroupsCache()
575 m_reg := ®isterer{}
576 m_grp.Registerer(nil, MetricGroupsCacheGaugeRegistererFunc(m_reg.RegisterGauge))
577 m_grp.GGet("gautotest1")
580 func TestMetricCounterAutoGGet(t *testing.T) {
581 m_grp := NewMetricGroupsCacheWithRegisterers(nil, ®isterer{})
582 m_grp.GGet("gautotest1")
585 func TestMetricCounterAutoGInc(t *testing.T) {
586 m_grp := NewMetricGroupsCache()
587 m_grp.Registerer(nil, ®isterer{})
588 m_grp.GInc("gautotest1")
591 func TestMetricCounterAutoGSet(t *testing.T) {
592 m_grp := NewMetricGroupsCache()
593 m_grp.Registerer(nil, ®isterer{})
594 m_grp.GSet("gautotest1", float64(10))
597 func TestMetricCounterAutoGAdd(t *testing.T) {
598 m_grp := NewMetricGroupsCache()
599 m_grp.Registerer(nil, ®isterer{})
600 m_grp.GAdd("gautotest1", float64(10))
603 func TestMetricCounterAutoGDec(t *testing.T) {
604 m_grp := NewMetricGroupsCache()
605 m_grp.Registerer(nil, ®isterer{})
606 m_grp.GDec("gautotest1")
610 // VECTORS ARE OLD WAY
611 // *Labeled* will do all work under the hood
614 var mCVect CounterVec
617 var mCGroupVect map[string]CounterVec
618 var mGGroupVect map[string]GaugeVec
620 func TestMetricSetup(t *testing.T) {
621 mCVect = Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
623 mCGroupVect = Metric.RegisterCounterVecGroup(
625 {Name: "counter1", Help: "counter1"},
627 []string{"name", "event"},
630 mGVect = Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
632 mGGroupVect = Metric.RegisterGaugeVecGroup(
634 {Name: "gauge1", Help: "gauge1"},
636 []string{"name", "event"},
639 tmpCVect := Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
641 if tmpCVect.Vec != mCVect.Vec {
642 t.Errorf("tmpCVect not same than mCVect. cache not working?")
645 tmpGVect := Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
647 if tmpGVect.Vec != mGVect.Vec {
648 t.Errorf("tmpGVect not same than mGVect. cache not working?")
653 func TestMetricCounterVector(t *testing.T) {
656 c_1_1 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
658 c_1_2 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
661 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
665 c_2_1 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
667 c_2_2 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
670 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
673 t.Errorf("c_1_1 same than c_2_1. what?")
678 func TestMetricCounterGroupVector(t *testing.T) {
681 c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect)
682 if _, ok := c_grp1["counter1"]; ok == false {
683 t.Errorf("c_grp1 counter1 not exists")
685 c_grp1["counter1"].Inc()
689 c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
690 if _, ok := c_grp2["counter1"]; ok == false {
691 t.Errorf("c_grp2 counter1 not exists")
693 c_grp2["counter1"].Inc()
696 func TestMetricGaugeVector(t *testing.T) {
699 c_1_1 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
701 c_1_2 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
704 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
708 c_2_1 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
710 c_2_2 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
713 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
716 t.Errorf("c_1_1 same than c_2_1. what?")
720 func TestMetricGaugeGroupVector(t *testing.T) {
723 g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect)
724 if _, ok := g_grp1["gauge1"]; ok == false {
725 t.Errorf("g_grp1 gauge1 not exists")
727 g_grp1["gauge1"].Inc()
731 g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
732 if _, ok := g_grp2["gauge1"]; ok == false {
733 t.Errorf("g_grp2 gauge1 not exists")
735 g_grp2["gauge1"].Inc()
738 func TestMetricCounterGroupVectorPrefix(t *testing.T) {
741 c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCGroupVect)
742 if _, ok := c_grp1["event1_counter1"]; ok == false {
743 t.Errorf("c_grp1 event1_counter1 not exists")
745 c_grp1["event1_counter1"].Inc()
749 c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCGroupVect)
750 if _, ok := c_grp2["event2_counter1"]; ok == false {
751 t.Errorf("c_grp2 event2_counter1 not exists")
753 c_grp2["event2_counter1"].Inc()
757 m_grp := NewMetricGroupsCache()
758 m_grp.CombineCounterGroups(c_grp1, c_grp2)
762 if m_grp.CIs("event1_counter1") == false {
763 t.Errorf("m_grp event1_counter1 not exists")
765 m_grp.CInc("event1_counter1")
769 if m_grp.CIs("event2_counter1") == false {
770 t.Errorf("m_grp event2_counter1 not exists")
773 m_grp.CAdd("event2_counter1", 1)
774 m_grp.CGet("event2_counter1")
777 func TestMetricGaugeGroupVectorPrefix(t *testing.T) {
780 g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGGroupVect)
781 if _, ok := g_grp1["event1_gauge1"]; ok == false {
782 t.Errorf("g_grp1 event1_gauge1 not exists")
784 g_grp1["event1_gauge1"].Inc()
788 g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGGroupVect)
789 if _, ok := g_grp2["event2_gauge1"]; ok == false {
790 t.Errorf("g_grp2 event2_gauge1 not exists")
792 g_grp2["event2_gauge1"].Inc()
794 m_grp := NewMetricGroupsCache()
795 m_grp.CombineGaugeGroups(g_grp1, g_grp2)
799 if m_grp.GIs("event1_gauge1") == false {
800 t.Errorf("m_grp event1_gauge1 not exists")
802 m_grp.GInc("event1_gauge1")
806 if m_grp.GIs("event2_gauge1") == false {
807 t.Errorf("m_grp event2_gauge1 not exists")
809 m_grp.GInc("event2_gauge1")
811 m_grp.GGet("event2_gauge1")
812 m_grp.GDec("event2_gauge1")
813 m_grp.GSet("event2_gauge1", 1)
816 func TestMetricGroupCacheWithVect(t *testing.T) {
819 c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect)
820 if _, ok := c_grp1["counter1"]; ok == false {
821 t.Errorf("c_grp1 counter1 not exists")
823 c_grp1["counter1"].Inc()
827 c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
828 if _, ok := c_grp2["counter1"]; ok == false {
829 t.Errorf("c_grp2 counter1 not exists")
831 c_grp2["counter1"].Inc()
835 g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect)
836 if _, ok := g_grp1["gauge1"]; ok == false {
837 t.Errorf("g_grp1 gauge1 not exists")
839 g_grp1["gauge1"].Inc()
843 g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
844 if _, ok := g_grp2["gauge1"]; ok == false {
845 t.Errorf("g_grp2 gauge1 not exists")
847 g_grp2["gauge1"].Inc()
851 m_grp := NewMetricGroupsCache()
852 m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1)
853 m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2)
854 m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1)
855 m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2)
858 t.Errorf("Cache failed")
861 if m_grp.CIs("event1_counter1") == false {
862 t.Errorf("m_grp.Counters event1_counter1 not exists")
864 m_grp.CInc("event1_counter1")
866 if m_grp.CIs("event2_counter1") == false {
867 t.Errorf("m_grp.Counters event2_counter1 not exists")
869 m_grp.CInc("event2_counter1")
871 if m_grp.GIs("event1_gauge1") == false {
872 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
874 m_grp.GInc("event1_gauge1")
876 if m_grp.GIs("event2_gauge1") == false {
877 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
879 m_grp.GInc("event2_gauge1")
881 m_grp.CAdd("event2_counter1", 1)
882 m_grp.CGet("event2_counter1")
883 m_grp.GGet("event2_gauge1")
884 m_grp.GDec("event2_gauge1")
885 m_grp.GSet("event2_gauge1", 1)