pkg/xapp/metrics_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   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
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  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 ==================================================================================
  18 */
  19
  20 package xapp
  21
  22 import (
  23         "testing"
  24 )
  25
  26 func TestMetricCounter(t *testing.T) {
  27         TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"}
  28         ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
  29         ret1.Inc()
  30         ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
  31         ret2.Inc()
  32         if ret1 != ret2 {
  33                 t.Errorf("ret1 not same than ret2. cache not working?")
  34         }
  35 }
  36
  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"},
  43         }
  44
  45         ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
  46
  47         if len(ret1) == 0 {
  48                 t.Errorf("ret1 counter group is empty")
  49         }
  50
  51         ret1["CounterBlaah1"].Inc()
  52         ret1["CounterBlaah2"].Inc()
  53         ret1["CounterBlaah3"].Inc()
  54         ret1["CounterBlaah4"].Inc()
  55
  56         ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
  57
  58         if len(ret2) == 0 {
  59                 t.Errorf("ret2 counter group is empty")
  60         }
  61
  62         ret2["CounterBlaah1"].Inc()
  63         ret2["CounterBlaah2"].Inc()
  64         ret2["CounterBlaah3"].Inc()
  65         ret2["CounterBlaah4"].Inc()
  66
  67         if len(ret1) != len(ret2) {
  68                 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
  69         }
  70 }
  71
  72 func TestMetricLabeledCounter(t *testing.T) {
  73         //
  74         //
  75         c_1_1 := Metric.RegisterLabeledCounter(
  76                 CounterOpts{Name: "counter1", Help: "counter1"},
  77                 []string{"name", "event"},
  78                 []string{"name1", "event1"},
  79                 "SUBSYSTEML0")
  80
  81         c_1_2 := Metric.RegisterLabeledCounter(
  82                 CounterOpts{Name: "counter1", Help: "counter1"},
  83                 []string{"name", "event"},
  84                 []string{"name1", "event1"},
  85                 "SUBSYSTEML0")
  86
  87         c_1_1.Inc()
  88         c_1_2.Inc()
  89         if c_1_1 != c_1_2 {
  90                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
  91         }
  92
  93         //
  94         //
  95         c_2_1 := Metric.RegisterLabeledCounter(
  96                 CounterOpts{Name: "counter1", Help: "counter1"},
  97                 []string{"name", "event"},
  98                 []string{"name1", "event2"},
  99                 "SUBSYSTEML0")
 100
 101         c_2_2 := Metric.RegisterLabeledCounter(
 102                 CounterOpts{Name: "counter1", Help: "counter1"},
 103                 []string{"name", "event"},
 104                 []string{"name1", "event2"},
 105                 "SUBSYSTEML0")
 106
 107         c_2_1.Inc()
 108         c_2_2.Inc()
 109         if c_2_1 != c_2_2 {
 110                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 111         }
 112
 113         if c_1_1 == c_2_1 {
 114                 t.Errorf("c_1_1 same than c_2_1. what?")
 115         }
 116         if c_1_2 == c_2_2 {
 117                 t.Errorf("c_1_2 same than c_2_2. what?")
 118         }
 119
 120 }
 121
 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")
 128
 129         ret := Metric.RegisterLabeledCounter(
 130                 CounterOpts{Name: "counter1", Help: "counter1"},
 131                 []string{"name", "eventmiss"},
 132                 []string{"name1", "event1"},
 133                 "SUBSYSTEMLERRMISSMATCH")
 134
 135         if ret != nil {
 136                 t.Errorf("Returned counter even its labels are mismatching")
 137         }
 138
 139         ret = Metric.RegisterLabeledCounter(
 140                 CounterOpts{Name: "counter1", Help: "counter1"},
 141                 []string{"name"},
 142                 []string{"name1"},
 143                 "SUBSYSTEMLERRMISSMATCH")
 144
 145         if ret != nil {
 146                 t.Errorf("Returned counter even its labels are mismatching")
 147         }
 148
 149 }
 150
 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")
 157
 158         ret := Metric.RegisterLabeledCounter(
 159                 CounterOpts{Name: "counter1", Help: "counter1"},
 160                 []string{"event", "name"},
 161                 []string{"name1", "event1"},
 162                 "SUBSYSTEMLERRWRONGORDER")
 163
 164         if ret != nil {
 165                 t.Errorf("Returned counter even its labels order is wrong")
 166         }
 167 }
 168
 169 func TestMetricLabeledCounterCounterNameExists(t *testing.T) {
 170         Metric.RegisterCounter(
 171                 CounterOpts{Name: "counter1", Help: "counter1"},
 172                 "SUBSYSTEMLERRNAMEEXISTS")
 173
 174         ret := Metric.RegisterLabeledCounter(
 175                 CounterOpts{Name: "counter1", Help: "counter1"},
 176                 []string{"name", "event"},
 177                 []string{"name1", "event1"},
 178                 "SUBSYSTEMLERRNAMEEXISTS")
 179
 180         if ret != nil {
 181                 t.Errorf("Returned labeled counter even its name conflicts with existing counter name")
 182         }
 183 }
 184
 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")
 191
 192         ret := Metric.RegisterCounter(
 193                 CounterOpts{Name: "counter2", Help: "counter2"},
 194                 "SUBSYSTEMLERRNAMEEXISTS")
 195
 196         if ret != nil {
 197                 t.Errorf("Returned counter even its name conflicts with existing labeled counter name")
 198         }
 199 }
 200
 201 func TestMetricLabeledCounterGroup(t *testing.T) {
 202         //
 203         //
 204         c_grp1 := Metric.RegisterLabeledCounterGroup(
 205                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 206                 []string{"name", "event"},
 207                 []string{"name1", "event1"},
 208                 "SUBSYSTEML1")
 209
 210         if _, ok := c_grp1["counter1"]; ok == false {
 211                 t.Errorf("c_grp1 counter1 not exists")
 212         }
 213         c_grp1["counter1"].Inc()
 214
 215         //
 216         //
 217         c_grp2 := Metric.RegisterLabeledCounterGroup(
 218                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 219                 []string{"name", "event"},
 220                 []string{"name1", "event2"},
 221                 "SUBSYSTEML1")
 222
 223         if _, ok := c_grp2["counter1"]; ok == false {
 224                 t.Errorf("c_grp2 counter1 not exists")
 225         }
 226         c_grp2["counter1"].Inc()
 227 }
 228
 229 func TestMetricGauge(t *testing.T) {
 230         TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"}
 231         ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
 232         ret1.Inc()
 233         ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
 234         ret2.Inc()
 235         if ret1 != ret2 {
 236                 t.Errorf("ret1 not same than ret2. cache not working?")
 237         }
 238 }
 239
 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"},
 246         }
 247
 248         ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
 249
 250         if len(ret1) == 0 {
 251                 t.Errorf("ret1 gauge group is empty")
 252         }
 253
 254         ret1["GaugeBlaah1"].Inc()
 255         ret1["GaugeBlaah2"].Inc()
 256         ret1["GaugeBlaah3"].Inc()
 257         ret1["GaugeBlaah4"].Inc()
 258
 259         ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
 260
 261         if len(ret2) == 0 {
 262                 t.Errorf("ret2 gauge group is empty")
 263         }
 264
 265         ret2["GaugeBlaah1"].Inc()
 266         ret2["GaugeBlaah2"].Inc()
 267         ret2["GaugeBlaah3"].Inc()
 268         ret2["GaugeBlaah4"].Inc()
 269
 270         if len(ret1) != len(ret2) {
 271                 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
 272         }
 273 }
 274
 275 func TestMetricLabeledGauge(t *testing.T) {
 276         //
 277         //
 278         c_1_1 := Metric.RegisterLabeledGauge(
 279                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 280                 []string{"name", "event"},
 281                 []string{"name1", "event1"},
 282                 "SUBSYSTEML0")
 283
 284         c_1_2 := Metric.RegisterLabeledGauge(
 285                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 286                 []string{"name", "event"},
 287                 []string{"name1", "event1"},
 288                 "SUBSYSTEML0")
 289
 290         c_1_1.Inc()
 291         c_1_2.Inc()
 292         if c_1_1 != c_1_2 {
 293                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
 294         }
 295
 296         //
 297         //
 298         c_2_1 := Metric.RegisterLabeledGauge(
 299                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 300                 []string{"name", "event"},
 301                 []string{"name1", "event2"},
 302                 "SUBSYSTEML0")
 303
 304         c_2_2 := Metric.RegisterLabeledGauge(
 305                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 306                 []string{"name", "event"},
 307                 []string{"name1", "event2"},
 308                 "SUBSYSTEML0")
 309
 310         c_2_1.Inc()
 311         c_2_2.Inc()
 312         if c_2_1 != c_2_2 {
 313                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 314         }
 315
 316         if c_1_1 == c_2_1 {
 317                 t.Errorf("c_1_1 same than c_2_1. what?")
 318         }
 319         if c_1_2 == c_2_2 {
 320                 t.Errorf("c_1_2 same than c_2_2. what?")
 321         }
 322
 323 }
 324
 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")
 331
 332         ret := Metric.RegisterLabeledGauge(
 333                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 334                 []string{"name", "eventmiss"},
 335                 []string{"name1", "event1"},
 336                 "SUBSYSTEMLERRMISSMATCH")
 337
 338         if ret != nil {
 339                 t.Errorf("Returned gauge even its labels are mismatching")
 340         }
 341
 342         ret = Metric.RegisterLabeledGauge(
 343                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 344                 []string{"name"},
 345                 []string{"name1"},
 346                 "SUBSYSTEMLERRMISSMATCH")
 347
 348         if ret != nil {
 349                 t.Errorf("Returned gauge even its labels are mismatching")
 350         }
 351
 352 }
 353
 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")
 360
 361         ret := Metric.RegisterLabeledGauge(
 362                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 363                 []string{"event", "name"},
 364                 []string{"name1", "event1"},
 365                 "SUBSYSTEMLERRWRONGORDER")
 366
 367         if ret != nil {
 368                 t.Errorf("Returned gauge even its labels order is wrong")
 369         }
 370
 371 }
 372
 373 func TestMetricLabeledGaugeGaugeNameExists(t *testing.T) {
 374         Metric.RegisterGauge(
 375                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 376                 "SUBSYSTEMLERRNAMEEXISTS")
 377
 378         ret := Metric.RegisterLabeledGauge(
 379                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 380                 []string{"name", "event"},
 381                 []string{"name1", "event1"},
 382                 "SUBSYSTEMLERRNAMEEXISTS")
 383
 384         if ret != nil {
 385                 t.Errorf("Returned labeled gauge even its name conflicts with existing gauge name")
 386         }
 387 }
 388
 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")
 395
 396         ret := Metric.RegisterGauge(
 397                 CounterOpts{Name: "gauge2", Help: "gauge2"},
 398                 "SUBSYSTEMLERRNAMEEXISTS")
 399
 400         if ret != nil {
 401                 t.Errorf("Returned gauge even its name conflicts with existing labeled gauge name")
 402         }
 403 }
 404
 405 func TestMetricLabeledGaugeGroup(t *testing.T) {
 406         //
 407         //
 408         g_grp1 := Metric.RegisterLabeledGaugeGroup(
 409                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 410                 []string{"name", "event"},
 411                 []string{"name1", "event1"},
 412                 "SUBSYSTEML1")
 413
 414         if _, ok := g_grp1["gauge1"]; ok == false {
 415                 t.Errorf("g_grp1 gauge1 not exists")
 416         }
 417         g_grp1["gauge1"].Inc()
 418
 419         //
 420         //
 421         g_grp2 := Metric.RegisterLabeledGaugeGroup(
 422                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 423                 []string{"name", "event"},
 424                 []string{"name1", "event2"},
 425                 "SUBSYSTEML1")
 426
 427         if _, ok := g_grp2["gauge1"]; ok == false {
 428                 t.Errorf("g_grp2 gauge1 not exists")
 429         }
 430         g_grp2["gauge1"].Inc()
 431 }
 432
 433 func TestMetricGroupCache(t *testing.T) {
 434         //
 435         //
 436         c_grp1 := Metric.RegisterLabeledCounterGroup(
 437                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 438                 []string{"name", "event"},
 439                 []string{"name1", "event1"},
 440                 "SUBSYSTEML1")
 441         if _, ok := c_grp1["counter1"]; ok == false {
 442                 t.Errorf("c_grp1 counter1 not exists")
 443         }
 444         c_grp1["counter1"].Inc()
 445
 446         //
 447         //
 448         c_grp2 := Metric.RegisterLabeledCounterGroup(
 449                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 450                 []string{"name", "event"},
 451                 []string{"name1", "event2"},
 452                 "SUBSYSTEML1")
 453         if _, ok := c_grp2["counter1"]; ok == false {
 454                 t.Errorf("c_grp2 counter1 not exists")
 455         }
 456         c_grp2["counter1"].Inc()
 457
 458         //
 459         //
 460         g_grp1 := Metric.RegisterLabeledGaugeGroup(
 461                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 462                 []string{"name", "event"},
 463                 []string{"name1", "event1"},
 464                 "SUBSYSTEML1")
 465         if _, ok := g_grp1["gauge1"]; ok == false {
 466                 t.Errorf("g_grp1 gauge1 not exists")
 467         }
 468         g_grp1["gauge1"].Inc()
 469
 470         //
 471         //
 472         g_grp2 := Metric.RegisterLabeledGaugeGroup(
 473                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 474                 []string{"name", "event"},
 475                 []string{"name1", "event2"},
 476                 "SUBSYSTEML1")
 477         if _, ok := g_grp2["gauge1"]; ok == false {
 478                 t.Errorf("g_grp2 gauge1 not exists")
 479         }
 480         g_grp2["gauge1"].Inc()
 481
 482         //
 483         //
 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)
 489
 490         if m_grp == nil {
 491                 t.Errorf("Cache failed")
 492         }
 493
 494         if m_grp.CIs("event1_counter1") == false {
 495                 t.Errorf("m_grp.Counters event1_counter1 not exists")
 496         }
 497         m_grp.CInc("event1_counter1")
 498
 499         if m_grp.CIs("event2_counter1") == false {
 500                 t.Errorf("m_grp.Counters event2_counter1 not exists")
 501         }
 502         m_grp.CInc("event2_counter1")
 503
 504         if m_grp.GIs("event1_gauge1") == false {
 505                 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
 506         }
 507         m_grp.GInc("event1_gauge1")
 508
 509         if m_grp.GIs("event2_gauge1") == false {
 510                 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
 511         }
 512         m_grp.GInc("event2_gauge1")
 513
 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)
 519 }
 520
 521 type registerer struct{}
 522
 523 func (met *registerer) RegisterCounter(opts CounterOpts) Counter {
 524         return Metric.RegisterLabeledCounter(
 525                 opts,
 526                 []string{"host", "interface"},
 527                 []string{"testhost", "testinterface"},
 528                 "SUBSYSTEMAUTO")
 529 }
 530
 531 func (met *registerer) RegisterGauge(opts CounterOpts) Gauge {
 532         return Metric.RegisterLabeledGauge(
 533                 opts,
 534                 []string{"host", "interface"},
 535                 []string{"testhost", "testinterface"},
 536                 "SUBSYSTEMAUTO")
 537 }
 538
 539 func TestMetricCounterAutoCGetNoReg(t *testing.T) {
 540         m_grp := NewMetricGroupsCache()
 541         m_grp.CGet("cautotest1")
 542 }
 543
 544 func TestMetricCounterAutoCGetFunc(t *testing.T) {
 545         m_grp := NewMetricGroupsCache()
 546         m_reg := &registerer{}
 547         m_grp.Registerer(MetricGroupsCacheCounterRegistererFunc(m_reg.RegisterCounter), nil)
 548         m_grp.CGet("cautotest1")
 549 }
 550
 551 func TestMetricCounterAutoCGet(t *testing.T) {
 552         m_grp := NewMetricGroupsCacheWithRegisterers(&registerer{}, nil)
 553         m_grp.CGet("cautotest1")
 554 }
 555
 556 func TestMetricCounterAutoCInc(t *testing.T) {
 557         m_grp := NewMetricGroupsCache()
 558         m_grp.Registerer(&registerer{}, nil)
 559         m_grp.CInc("cautotest1")
 560 }
 561
 562 func TestMetricCounterAutoCAdd(t *testing.T) {
 563         m_grp := NewMetricGroupsCache()
 564         m_grp.Registerer(&registerer{}, nil)
 565         m_grp.CAdd("cautotest1", float64(10))
 566 }
 567
 568 func TestMetricCounterAutoGGetNoReg(t *testing.T) {
 569         m_grp := NewMetricGroupsCache()
 570         m_grp.GGet("gautotest1")
 571 }
 572
 573 func TestMetricCounterAutoGGetFunc(t *testing.T) {
 574         m_grp := NewMetricGroupsCache()
 575         m_reg := &registerer{}
 576         m_grp.Registerer(nil, MetricGroupsCacheGaugeRegistererFunc(m_reg.RegisterGauge))
 577         m_grp.GGet("gautotest1")
 578 }
 579
 580 func TestMetricCounterAutoGGet(t *testing.T) {
 581         m_grp := NewMetricGroupsCacheWithRegisterers(nil, &registerer{})
 582         m_grp.GGet("gautotest1")
 583 }
 584
 585 func TestMetricCounterAutoGInc(t *testing.T) {
 586         m_grp := NewMetricGroupsCache()
 587         m_grp.Registerer(nil, &registerer{})
 588         m_grp.GInc("gautotest1")
 589 }
 590
 591 func TestMetricCounterAutoGSet(t *testing.T) {
 592         m_grp := NewMetricGroupsCache()
 593         m_grp.Registerer(nil, &registerer{})
 594         m_grp.GSet("gautotest1", float64(10))
 595 }
 596
 597 func TestMetricCounterAutoGAdd(t *testing.T) {
 598         m_grp := NewMetricGroupsCache()
 599         m_grp.Registerer(nil, &registerer{})
 600         m_grp.GAdd("gautotest1", float64(10))
 601 }
 602
 603 func TestMetricCounterAutoGDec(t *testing.T) {
 604         m_grp := NewMetricGroupsCache()
 605         m_grp.Registerer(nil, &registerer{})
 606         m_grp.GDec("gautotest1")
 607 }