Use string for Histogram names since these are all ASCII anyway wide-characte...

base/histogram_unittest.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Test of Histogram class
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace {
 
 class HistogramTest : public testing::Test {
 };
 
 // Check for basic syntax and use.
 TEST(HistogramTest, StartupShutdownTest) {
   // Try basic construction
-  Histogram histogram(L"TestHistogram", 1, 1000, 10);
-  Histogram histogram1(L"Test1Histogram", 1, 1000, 10);
+  Histogram histogram("TestHistogram", 1, 1000, 10);
+  Histogram histogram1("Test1Histogram", 1, 1000, 10);
 
-  LinearHistogram linear_histogram(L"TestLinearHistogram", 1, 1000, 10);
-  LinearHistogram linear_histogram1(L"Test1LinearHistogram", 1, 1000, 10);
+  LinearHistogram linear_histogram("TestLinearHistogram", 1, 1000, 10);
+  LinearHistogram linear_histogram1("Test1LinearHistogram", 1, 1000, 10);
 
   // Use standard macros (but with fixed samples)
-  HISTOGRAM_TIMES(L"Test2Histogram", TimeDelta::FromDays(1));
-  HISTOGRAM_COUNTS(L"Test3Histogram", 30);
+  HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
+  HISTOGRAM_COUNTS("Test3Histogram", 30);
 
-  DHISTOGRAM_TIMES(L"Test4Histogram", TimeDelta::FromDays(1));
-  DHISTOGRAM_COUNTS(L"Test5Histogram", 30);
+  DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
+  DHISTOGRAM_COUNTS("Test5Histogram", 30);
 
-  ASSET_HISTOGRAM_COUNTS(L"Test6Histogram", 129);
+  ASSET_HISTOGRAM_COUNTS("Test6Histogram", 129);
 
   // Try to construct samples.
   Histogram::SampleSet sample1;
   Histogram::SampleSet sample2;
 
   // Use copy constructor of SampleSet
   sample1 = sample2;
   Histogram::SampleSet sample3(sample1);
 
   // Finally test a statistics recorder, without really using it.
   StatisticsRecorder recorder;
 }
 
 // Repeat with a recorder present to register with.
 TEST(HistogramTest, RecordedStartupTest) {
   // Test a statistics recorder, by letting histograms register.
   StatisticsRecorder recorder;  // This initializes the global state.
 
   StatisticsRecorder::Histograms histograms;
   EXPECT_EQ(0U, histograms.size());
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(0U, histograms.size());
 
   // Try basic construction
-  Histogram histogram(L"TestHistogram", 1, 1000, 10);
+  Histogram histogram("TestHistogram", 1, 1000, 10);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(1U, histograms.size());
-  Histogram histogram1(L"Test1Histogram", 1, 1000, 10);
+  Histogram histogram1("Test1Histogram", 1, 1000, 10);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(2U, histograms.size());
 
-  LinearHistogram linear_histogram(L"TestLinearHistogram", 1, 1000, 10);
-  LinearHistogram linear_histogram1(L"Test1LinearHistogram", 1, 1000, 10);
+  LinearHistogram linear_histogram("TestLinearHistogram", 1, 1000, 10);
+  LinearHistogram linear_histogram1("Test1LinearHistogram", 1, 1000, 10);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(4U, histograms.size());
 
   // Use standard macros (but with fixed samples)
-  HISTOGRAM_TIMES(L"Test2Histogram", TimeDelta::FromDays(1));
-  HISTOGRAM_COUNTS(L"Test3Histogram", 30);
+  HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
+  HISTOGRAM_COUNTS("Test3Histogram", 30);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(6U, histograms.size());
 
-  ASSET_HISTOGRAM_COUNTS(L"TestAssetHistogram", 1000);
+  ASSET_HISTOGRAM_COUNTS("TestAssetHistogram", 1000);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(7U, histograms.size());
 
-  DHISTOGRAM_TIMES(L"Test4Histogram", TimeDelta::FromDays(1));
-  DHISTOGRAM_COUNTS(L"Test5Histogram", 30);
+  DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
+  DHISTOGRAM_COUNTS("Test5Histogram", 30);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
 #ifndef NDEBUG
   EXPECT_EQ(9U, histograms.size());
 #else
   EXPECT_EQ(7U, histograms.size());
 #endif
 }
 
 TEST(HistogramTest, RangeTest) {
   StatisticsRecorder recorder;
   StatisticsRecorder::Histograms histograms;
 
   recorder.GetHistograms(&histograms);
   EXPECT_EQ(0U, histograms.size());
 
-  Histogram histogram(L"Histogram", 1, 64, 8);  // As mentioned in header file.
+  Histogram histogram("Histogram", 1, 64, 8);  // As mentioned in header file.
   // Check that we got a nice exponential when there was enough rooom.
   EXPECT_EQ(0, histogram.ranges(0));
   int power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     EXPECT_EQ(power_of_2, histogram.ranges(i));
     power_of_2 *= 2;
   }
   EXPECT_EQ(INT_MAX, histogram.ranges(8));
 
-  Histogram short_histogram(L"Histogram Shortened", 1, 7, 8);
+  Histogram short_histogram("Histogram Shortened", 1, 7, 8);
   // Check that when the number of buckets is short, we get a linear histogram
   // for lack of space to do otherwise.
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i, short_histogram.ranges(i));
   EXPECT_EQ(INT_MAX, short_histogram.ranges(8));
 
-  LinearHistogram linear_histogram(L"Linear", 1, 7, 8);
+  LinearHistogram linear_histogram("Linear", 1, 7, 8);
   // We also get a nice linear set of bucket ranges when we ask for it
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i, linear_histogram.ranges(i));
   EXPECT_EQ(INT_MAX, linear_histogram.ranges(8));
 
-  LinearHistogram linear_broad_histogram(L"Linear widened", 2, 14, 8);
+  LinearHistogram linear_broad_histogram("Linear widened", 2, 14, 8);
   // ...but when the list has more space, then the ranges naturally spread out.
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(2 * i, linear_broad_histogram.ranges(i));
   EXPECT_EQ(INT_MAX, linear_broad_histogram.ranges(8));
 
-  ThreadSafeHistogram threadsafe_histogram(L"ThreadSafe", 1, 32, 15);
+  ThreadSafeHistogram threadsafe_histogram("ThreadSafe", 1, 32, 15);
   // When space is a little tight, we transition from linear to exponential.
   // This is what happens in both the basic histogram, and the threadsafe
   // variant (which is derived).
   EXPECT_EQ(0, threadsafe_histogram.ranges(0));
   EXPECT_EQ(1, threadsafe_histogram.ranges(1));
   EXPECT_EQ(2, threadsafe_histogram.ranges(2));
   EXPECT_EQ(3, threadsafe_histogram.ranges(3));
   EXPECT_EQ(4, threadsafe_histogram.ranges(4));
   EXPECT_EQ(5, threadsafe_histogram.ranges(5));
   EXPECT_EQ(6, threadsafe_histogram.ranges(6));
   EXPECT_EQ(7, threadsafe_histogram.ranges(7));
   EXPECT_EQ(9, threadsafe_histogram.ranges(8));
   EXPECT_EQ(11, threadsafe_histogram.ranges(9));
   EXPECT_EQ(14, threadsafe_histogram.ranges(10));
   EXPECT_EQ(17, threadsafe_histogram.ranges(11));
   EXPECT_EQ(21, threadsafe_histogram.ranges(12));
   EXPECT_EQ(26, threadsafe_histogram.ranges(13));
   EXPECT_EQ(32, threadsafe_histogram.ranges(14));
   EXPECT_EQ(INT_MAX, threadsafe_histogram.ranges(15));
 
   recorder.GetHistograms(&histograms);
   EXPECT_EQ(5U, histograms.size());
 }
 
 // Make sure histogram handles out-of-bounds data gracefully.
 TEST(HistogramTest, BoundsTest) {
   const size_t kBucketCount = 50;
-  Histogram histogram(L"Bounded", 10, 100, kBucketCount);
+  Histogram histogram("Bounded", 10, 100, kBucketCount);
 
   // Put two samples "out of bounds" above and below.
   histogram.Add(5);
   histogram.Add(-50);
 
   histogram.Add(100);
   histogram.Add(10000);
 
   // Verify they landed in the underflow, and overflow buckets.
   Histogram::SampleSet sample;
   histogram.SnapshotSample(&sample);
   EXPECT_EQ(2, sample.counts(0));
   EXPECT_EQ(0, sample.counts(1));
   size_t array_size = histogram.bucket_count();
   EXPECT_EQ(kBucketCount, array_size);
   EXPECT_EQ(0, sample.counts(array_size - 2));
   EXPECT_EQ(2, sample.counts(array_size - 1));
 }
 
 // Check to be sure samples land as expected is "correct" buckets.
 TEST(HistogramTest, BucketPlacementTest) {
-  Histogram histogram(L"Histogram", 1, 64, 8);  // As mentioned in header file.
+  Histogram histogram("Histogram", 1, 64, 8);  // As mentioned in header file.
 
   // Check that we got a nice exponential since there was enough rooom.
   EXPECT_EQ(0, histogram.ranges(0));
   int power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     EXPECT_EQ(power_of_2, histogram.ranges(i));
     power_of_2 *= 2;
   }
   EXPECT_EQ(INT_MAX, histogram.ranges(8));
 
   // Add i+1 samples to the i'th bucket.
   histogram.Add(0);
   power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     for (int j = 0; j <= i; j++)
       histogram.Add(power_of_2);
     power_of_2 *= 2;
   }
   // Leave overflow bucket empty.
 
   // Check to see that the bucket counts reflect our additions.
   Histogram::SampleSet sample;
   histogram.SnapshotSample(&sample);
   EXPECT_EQ(INT_MAX, histogram.ranges(8));
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i + 1, sample.counts(i));
 }
 
-static const wchar_t* kAssetTestHistogramName = L"AssetCountTest";
-static const wchar_t* kAssetTestDebugHistogramName = L"DAssetCountTest";
+static const char kAssetTestHistogramName[] = "AssetCountTest";
+static const char kAssetTestDebugHistogramName[] = "DAssetCountTest";
 void AssetCountFunction(int sample) {
   ASSET_HISTOGRAM_COUNTS(kAssetTestHistogramName, sample);
   DASSET_HISTOGRAM_COUNTS(kAssetTestDebugHistogramName, sample);
 }
 // Check that asset can be added and removed from buckets.
 TEST(HistogramTest, AssetCountTest) {
   // Start up a recorder system to identify all histograms.
   StatisticsRecorder recorder;
 
   // Call through the macro to instantiate the static variables.
   AssetCountFunction(100);  // Put a sample in the bucket for 100.
 
   // Find the histogram.
   StatisticsRecorder::Histograms histogram_list;
   StatisticsRecorder::GetHistograms(&histogram_list);
   ASSERT_NE(0U, histogram_list.size());
-  std::string ascii_name = WideToASCII(kAssetTestHistogramName);
-  std::string debug_ascii_name = WideToASCII(kAssetTestDebugHistogramName);
   const Histogram* our_histogram = NULL;
   const Histogram* our_debug_histogram = NULL;
   for (StatisticsRecorder::Histograms::iterator it = histogram_list.begin();
        it != histogram_list.end();
        ++it) {
-    if (!(*it)->histogram_name().compare(ascii_name))
+    if (!(*it)->histogram_name().compare(kAssetTestHistogramName))
       our_histogram = *it;
-    else if (!(*it)->histogram_name().compare(debug_ascii_name)) {
+    else if (!(*it)->histogram_name().compare(kAssetTestDebugHistogramName)) {
       our_debug_histogram = *it;
     }
   }
   ASSERT_TRUE(our_histogram);
 #ifndef NDEBUG
   EXPECT_TRUE(our_debug_histogram);
 #else
   EXPECT_FALSE(our_debug_histogram);
 #endif
   // Verify it has a 1 in exactly one bucket (where we put the sample).
@@ skipping 35 matching lines @@
   AssetCountFunction(-100);  // Remove a sample from the bucket for 100.
   our_debug_histogram->SnapshotSample(&sample);  // Extract data set.
 
   // Verify that the bucket is now empty, as are all the other buckets.
   for (size_t i = 0; i < our_debug_histogram->bucket_count(); ++i) {
     EXPECT_EQ(0, sample.counts(i)) << "extra count in bucket " << i;
   }
 }
 
 }  // namespace
-