← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to base/stats_config_util_test.cc

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/stats_config_util_test.cc
33
33
#include "base/base.h"
34
34
#include "base/singleton.h"
35
35
#include "base/stats_config_util.h"
 
36
#include "base/util.h"
36
37
#include "testing/base/public/gunit.h"
37
38
#ifdef OS_WINDOWS
38
39
#include "shared/opensource/patching/sidestep/cross/auto_testing_hook.h"
40
41
 
41
42
#ifdef OS_WINDOWS
42
43
 
43
 
// Users of the sidestep library need to supply these functions.
44
 
// See sidestep/cross/integration.h
45
 
// for more details.
46
 
// TODO(mazda): Make a library for these implementations.
47
 
namespace sidestep {
48
 
void AssertImpl(bool assertion_is_true, const char* message) {
49
 
  DCHECK(assertion_is_true) << message;
50
 
}
51
 
 
52
 
void LogImpl(const char* message) {
53
 
  DLOG(INFO) << message;
54
 
}
55
 
}  // sidestep
56
 
 
57
44
namespace {
58
45
const wchar_t kOmahaGUID[] = L"{DDCCD2A9-025E-4142-BCEB-F467B88CF830}";
59
46
const wchar_t kOmahaUsageKey[] =
274
261
  sidestep::AutoTestingHook hook_reg_delete_value_;
275
262
};
276
263
 
 
264
class StatsConfigUtilTestWin : public testing::Test {
 
265
 protected:
 
266
  static void SetUpTestCase() {
 
267
    // A quick fix of b/2669319.  If mozc::Util::GetSystemDir is first called
 
268
    // when registry APIs are hooked by sidestep, GetSystemDir fails
 
269
    // unexpectedly because GetSystemDir also depends on registry API
 
270
    // internally.  The second call of mozc::Util::GetSystemDir works well
 
271
    // because it caches the result of the first call.  So any registry API
 
272
    // access occurs in the second call.  We call mozc::Util::GetSystemDir here
 
273
    // so that it works even when registry APIs are hooked.
 
274
    // TODO(yukawa): remove this quick fix as a part of b/2769852.
 
275
    mozc::Util::GetSystemDir();
 
276
  }
 
277
};
277
278
}  // namespace
278
279
 
279
280
namespace mozc {
280
281
#if defined(CHANNEL_DEV)
281
 
TEST(StatsConfigUtilTestWinDevChannel, SetEnabledIgnoresRegistrySettings) {
 
282
TEST_F(StatsConfigUtilTestWin, IsEnabledIgnoresRegistrySettings) {
282
283
  // In dev channel, settings in the registry are simply ignored and
283
284
  // StatsConfigUtil::IsEnabled always returns true.
284
285
  RegistryEmulator<__COUNTER__> test;
333
334
  EXPECT_TRUE(StatsConfigUtil::IsEnabled());
334
335
}
335
336
 
336
 
TEST(StatsConfigUtilTestWinDevChannel, SetEnabledNeverFailsForRunLevelMedium) {
 
337
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelHighInDevChannel) {
 
338
  // In dev channel, StatsConfigUtil::SetEnabled always returns true.
 
339
  RegistryEmulator<__COUNTER__> test;
 
340
  test.SetRunLevel(kRunLevelHigh);
 
341
  DWORD value = 0;
 
342
 
 
343
  test.ClearUsagestatsValue();
 
344
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
345
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
346
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
347
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
348
  EXPECT_EQ(1, value);
 
349
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
350
 
 
351
  test.ClearUsagestatsValue();
 
352
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
353
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
354
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
355
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
356
  EXPECT_EQ(1, value);
 
357
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
358
 
 
359
  test.ClearUsagestatsValue();
 
360
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);  // disable usagestats
 
361
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
362
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
363
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
364
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
365
  EXPECT_EQ(1, value);
 
366
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));  // removed
 
367
 
 
368
  test.ClearUsagestatsValue();
 
369
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);  // enable usagestats
 
370
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
371
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
372
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
373
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
374
  EXPECT_EQ(1, value);
 
375
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));  // removed
 
376
}
 
377
 
 
378
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelMediumInDevChannel) {
 
379
  // In dev channel, StatsConfigUtil::SetEnabled always returns true.
 
380
  RegistryEmulator<__COUNTER__> test;
 
381
  test.SetRunLevel(kRunLevelMedium);
 
382
  DWORD value = 0;
 
383
 
 
384
  test.ClearUsagestatsValue();
 
385
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
386
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
387
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
388
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
389
 
 
390
  test.ClearUsagestatsValue();
 
391
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
392
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
393
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
394
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
395
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
396
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
397
  EXPECT_EQ(1, value);
 
398
 
 
399
  test.ClearUsagestatsValue();
 
400
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
401
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
402
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
403
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
404
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
405
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
406
  EXPECT_EQ(0, value);
 
407
 
 
408
  test.ClearUsagestatsValue();
 
409
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
410
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
411
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
412
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
413
 
 
414
  test.ClearUsagestatsValue();
 
415
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
416
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
417
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
418
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
419
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
420
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
421
  EXPECT_EQ(1, value);
 
422
 
 
423
  test.ClearUsagestatsValue();
 
424
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
425
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
426
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
427
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
428
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
429
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
430
  EXPECT_EQ(0, value);
 
431
}
 
432
 
 
433
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelLowInDevChannel) {
 
434
  // In dev channel, StatsConfigUtil::SetEnabled always returns true.
 
435
  RegistryEmulator<__COUNTER__> test;
 
436
  test.SetRunLevel(kRunLevelLow);
 
437
  DWORD value = 0;
 
438
 
 
439
  test.ClearUsagestatsValue();
 
440
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
441
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
442
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
443
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
444
 
 
445
  test.ClearUsagestatsValue();
 
446
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
447
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
448
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
449
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
450
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
451
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
452
  EXPECT_EQ(1, value);
 
453
 
 
454
  test.ClearUsagestatsValue();
 
455
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
456
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
457
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
458
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
459
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
460
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
461
  EXPECT_EQ(0, value);
 
462
 
 
463
  test.ClearUsagestatsValue();
 
464
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
465
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
466
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
467
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
468
 
 
469
  test.ClearUsagestatsValue();
 
470
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
471
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
472
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
473
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
474
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
475
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
476
  EXPECT_EQ(1, value);
 
477
 
 
478
  test.ClearUsagestatsValue();
 
479
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
480
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
481
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
482
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
483
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
484
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
485
  EXPECT_EQ(0, value);
 
486
}
 
487
 
 
488
TEST_F(StatsConfigUtilTestWin, SetEnabledNeverFailsForRunLevelMedium) {
337
489
  // In dev channel, StatsConfigUtil::SetEnabled does not update the
338
490
  // the registry but always returns true.
339
491
  RegistryEmulator<__COUNTER__> test;
342
494
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
343
495
}
344
496
 
345
 
TEST(StatsConfigUtilTestWinDevChannel, SetEnabledNeverFailsForRunLevelLow) {
 
497
TEST_F(StatsConfigUtilTestWin, SetEnabledNeverFailsForRunLevelLow) {
346
498
  // In dev channel, StatsConfigUtil::SetEnabled does not update the
347
499
  // the registry but always returns true.
348
500
  RegistryEmulator<__COUNTER__> test;
353
505
#endif  // CHANNEL_DEV
354
506
 
355
507
#if !defined(CHANNEL_DEV)
356
 
TEST(StatsConfigUtilTestWinNonDev, SetEnabledForRunLevelHigh) {
 
508
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelHigh) {
357
509
  // In beta and stable channel, StatsConfigUtil::SetEnabled requires
358
510
  // sufficient rights.
359
511
  RegistryEmulator<__COUNTER__> test;
360
512
  test.SetRunLevel(kRunLevelHigh);
 
513
  DWORD value = 0;
361
514
 
362
515
  // Check if SetEnabled(true) works as expected.
363
 
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
364
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
365
 
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
366
 
  DWORD value = 0;
367
 
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
368
 
  EXPECT_EQ(1, value);
369
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
370
 
 
371
 
  // Check if SetEnabled(false) works as expected.
372
 
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
373
 
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
374
 
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
375
 
  EXPECT_EQ(0, value);
 
516
  test.ClearUsagestatsValue();
 
517
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
518
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
519
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
520
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
521
  EXPECT_EQ(1, value);
 
522
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
523
 
 
524
  // Check if SetEnabled(true) merges kHKLM_ClientStateMedium.
 
525
  test.ClearUsagestatsValue();
 
526
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
527
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
528
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
529
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
530
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
531
  EXPECT_EQ(1, value);
 
532
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
533
 
 
534
  test.ClearUsagestatsValue();
 
535
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
536
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(true));
 
537
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
538
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
539
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
540
  EXPECT_EQ(1, value);
 
541
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
542
 
 
543
  // Check if SetEnabled(false) works as expected.
 
544
  test.ClearUsagestatsValue();
 
545
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
546
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
547
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
548
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
549
  EXPECT_EQ(0, value);
 
550
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
551
 
 
552
  // Check if SetEnabled(false) works as expected.
 
553
  test.ClearUsagestatsValue();
 
554
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
555
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
556
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
557
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
558
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
559
  EXPECT_EQ(0, value);
 
560
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
561
 
 
562
  test.ClearUsagestatsValue();
 
563
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
564
  EXPECT_TRUE(StatsConfigUtil::SetEnabled(false));
 
565
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
566
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientState));
 
567
  test.GetUsagestatsValue(kHKLM_ClientState, &value);
 
568
  EXPECT_EQ(0, value);
 
569
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
376
570
}
377
571
 
378
 
TEST(StatsConfigUtilTestWinNonDev, SetEnabledForRunLevelMedium) {
 
572
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelMedium) {
379
573
  // In beta and stable channels, StatsConfigUtil::SetEnabled requires
380
574
  // sufficient rights.
381
575
  RegistryEmulator<__COUNTER__> test;
382
 
 
383
576
  test.SetRunLevel(kRunLevelMedium);
384
 
  // Check if SetEnabled(true) fails as expected.
385
 
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
386
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
387
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
388
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
577
  DWORD value = 0;
 
578
 
 
579
  test.ClearUsagestatsValue();
 
580
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
581
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
582
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
583
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
584
 
 
585
  test.ClearUsagestatsValue();
 
586
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
587
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
588
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
589
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
590
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
591
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
592
  EXPECT_EQ(1, value);
 
593
 
 
594
  test.ClearUsagestatsValue();
 
595
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
596
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
597
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
598
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
599
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
600
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
601
  EXPECT_EQ(0, value);
 
602
 
 
603
  test.ClearUsagestatsValue();
 
604
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
605
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
606
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
607
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
608
 
 
609
  test.ClearUsagestatsValue();
 
610
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
611
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
612
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
613
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
614
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
615
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
616
  EXPECT_EQ(1, value);
 
617
 
 
618
  test.ClearUsagestatsValue();
 
619
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
620
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
621
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
622
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
623
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
624
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
625
  EXPECT_EQ(0, value);
389
626
}
390
627
 
391
 
TEST(StatsConfigUtilTestWinNonDev, SetEnabledForRunLevelLow) {
 
628
TEST_F(StatsConfigUtilTestWin, SetEnabledForRunLevelLow) {
392
629
  // In beta and stable channels, StatsConfigUtil::SetEnabled requires
393
630
  // sufficient rights.
394
631
  RegistryEmulator<__COUNTER__> test;
395
 
 
396
632
  test.SetRunLevel(kRunLevelLow);
 
633
  DWORD value = 0;
 
634
 
397
635
  // Check if SetEnabled(true) fails as expected.
398
 
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
399
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
400
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
401
 
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
636
  test.ClearUsagestatsValue();
 
637
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
638
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
639
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
640
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
641
 
 
642
  // Check if SetEnabled(false) fails as expected.
 
643
  test.ClearUsagestatsValue();
 
644
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
645
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
646
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
647
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
648
 
 
649
  test.ClearUsagestatsValue();
 
650
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
651
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
652
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
653
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
654
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
655
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
656
  EXPECT_EQ(1, value);
 
657
 
 
658
  test.ClearUsagestatsValue();
 
659
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
660
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(true));
 
661
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
662
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
663
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
664
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
665
  EXPECT_EQ(0, value);
 
666
 
 
667
  test.ClearUsagestatsValue();
 
668
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 1);
 
669
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
670
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
671
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
672
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
673
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
674
  EXPECT_EQ(1, value);
 
675
 
 
676
  test.ClearUsagestatsValue();
 
677
  test.SetUsagestatsValue(kHKLM_ClientStateMedium, 0);
 
678
  EXPECT_FALSE(StatsConfigUtil::SetEnabled(false));
 
679
  EXPECT_FALSE(test.HasUsagestatsValue(kHKCU_ClientState));
 
680
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientState));
 
681
  EXPECT_TRUE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
 
682
  test.GetUsagestatsValue(kHKLM_ClientStateMedium, &value);
 
683
  EXPECT_EQ(0, value);
402
684
}
403
685
 
404
 
TEST(StatsConfigUtilTestWinNonDev, IsEnabled) {
 
686
TEST_F(StatsConfigUtilTestWin, IsEnabled) {
405
687
  RegistryEmulator<__COUNTER__> test;
406
688
  test.SetRunLevel(kRunLevelHigh);
407
689
 
455
737
}
456
738
#endif  // !CHANNEL_DEV
457
739
 
458
 
TEST(StatsConfigUtilTestWin, RemoveDisablingHKCUEntryInIsEnabled) {
 
740
TEST_F(StatsConfigUtilTestWin, RemoveDisablingHKCUEntryInIsEnabled) {
459
741
  RegistryEmulator<__COUNTER__> test;
460
742
 
461
743
  test.SetRunLevel(kRunLevelHigh);
486
768
  EXPECT_EQ(0, value);
487
769
}
488
770
 
489
 
TEST(StatsConfigUtilTestWin, IsEnabledForRunLevelLow) {
 
771
TEST_F(StatsConfigUtilTestWin, IsEnabledForRunLevelLow) {
490
772
  RegistryEmulator<__COUNTER__> test;
491
773
 
492
774
  test.SetRunLevel(kRunLevelHigh);
516
798
  EXPECT_EQ(0, value);
517
799
}
518
800
 
519
 
TEST(StatsConfigUtilTestWin, RemoveEnablingHKCUEntryInIsEnabled) {
 
801
TEST_F(StatsConfigUtilTestWin, RemoveEnablingHKCUEntryInIsEnabled) {
520
802
  RegistryEmulator<__COUNTER__> test;
521
803
  test.SetRunLevel(kRunLevelMedium);
522
804
  // Enabling usagestats with wrong style (should be fixed).
539
821
  EXPECT_FALSE(test.HasUsagestatsValue(kHKLM_ClientStateMedium));
540
822
}
541
823
 
542
 
TEST(StatsConfigUtilTestWin,
543
 
     RemoveEnablingHKCUEntryInIsEnabledForRunLevelLow) {
 
824
TEST_F(StatsConfigUtilTestWin,
 
825
       RemoveEnablingHKCUEntryInIsEnabledForRunLevelLow) {
544
826
  RegistryEmulator<__COUNTER__> test;
545
827
  test.SetRunLevel(kRunLevelMedium);
546
828
  // Enabling usagestats with wrong style (should be fixed).