path: root/base/tracked_objects_unittest.cc

// Copyright (c) 2011 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 classes in the tracked_objects.h classes.

#include "base/tracked_objects.h"

#include "base/json/json_writer.h"
#include "base/memory/scoped_ptr.h"
#include "base/time.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace tracked_objects {

class TrackedObjectsTest : public testing::Test {
 public:
   ~TrackedObjectsTest() {
     ThreadData::ShutdownSingleThreadedCleanup();
   }

};

TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
  // Minimal test doesn't even create any tasks.
  if (!ThreadData::StartTracking(true))
    return;

  EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
  ThreadData* data = ThreadData::Get();
  EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
  EXPECT_TRUE(data);
  EXPECT_TRUE(!data->next());
  EXPECT_EQ(data, ThreadData::Get());
  ThreadData::BirthMap birth_map;
  data->SnapshotBirthMap(&birth_map);
  EXPECT_EQ(0u, birth_map.size());
  ThreadData::DeathMap death_map;
  data->SnapshotDeathMap(&death_map);
  EXPECT_EQ(0u, death_map.size());
  ThreadData::ShutdownSingleThreadedCleanup();

  // Do it again, just to be sure we reset state completely.
  ThreadData::StartTracking(true);
  EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
  data = ThreadData::Get();
  EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
  EXPECT_TRUE(data);
  EXPECT_TRUE(!data->next());
  EXPECT_EQ(data, ThreadData::Get());
  birth_map.clear();
  data->SnapshotBirthMap(&birth_map);
  EXPECT_EQ(0u, birth_map.size());
  death_map.clear();
  data->SnapshotDeathMap(&death_map);
  EXPECT_EQ(0u, death_map.size());
}

TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
  if (!ThreadData::StartTracking(true))
    return;

  // Instigate tracking on a single tracked object, on our thread.
  const Location& location = FROM_HERE;
  ThreadData::TallyABirthIfActive(location);

  const ThreadData* data = ThreadData::first();
  ASSERT_TRUE(data);
  EXPECT_TRUE(!data->next());
  EXPECT_EQ(data, ThreadData::Get());
  ThreadData::BirthMap birth_map;
  data->SnapshotBirthMap(&birth_map);
  EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
  EXPECT_EQ(1, birth_map.begin()->second->birth_count());  // 1 birth.
  ThreadData::DeathMap death_map;
  data->SnapshotDeathMap(&death_map);
  EXPECT_EQ(0u, death_map.size());                         // No deaths.


  // Now instigate a birth, and a death.
  const Births* second_birth = ThreadData::TallyABirthIfActive(location);
  ThreadData::TallyADeathIfActive(
      second_birth,
      base::TimeTicks(), /* Bogus post_time. */
      base::TimeTicks(), /* Bogus delayed_start_time. */
      base::TimeTicks(), /* Bogus start_run_time. */
      base::TimeTicks()  /* Bogus end_run_time */ );

  birth_map.clear();
  data->SnapshotBirthMap(&birth_map);
  EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
  EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
  death_map.clear();
  data->SnapshotDeathMap(&death_map);
  EXPECT_EQ(1u, death_map.size());                         // 1 location.
  EXPECT_EQ(1, death_map.begin()->second.count());         // 1 death.

  // The births were at the same location as the one known death.
  EXPECT_EQ(birth_map.begin()->second, death_map.begin()->first);
}

TEST_F(TrackedObjectsTest, DeathDataTest) {
  if (!ThreadData::StartTracking(true))
    return;

  scoped_ptr<DeathData> data(new DeathData());
  ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
  EXPECT_EQ(data->run_duration(), base::TimeDelta());
  EXPECT_EQ(data->queue_duration(), base::TimeDelta());
  EXPECT_EQ(data->AverageMsRunDuration(), 0);
  EXPECT_EQ(data->AverageMsQueueDuration(), 0);
  EXPECT_EQ(data->count(), 0);

  int run_ms = 42;
  int queue_ms = 8;

  base::TimeDelta run_duration = base::TimeDelta().FromMilliseconds(run_ms);
  base::TimeDelta queue_duration = base::TimeDelta().FromMilliseconds(queue_ms);
  data->RecordDeath(queue_duration, run_duration);
  EXPECT_EQ(data->run_duration(), run_duration);
  EXPECT_EQ(data->queue_duration(), queue_duration);
  EXPECT_EQ(data->AverageMsRunDuration(), run_ms);
  EXPECT_EQ(data->AverageMsQueueDuration(), queue_ms);
  EXPECT_EQ(data->count(), 1);

  data->RecordDeath(queue_duration, run_duration);
  EXPECT_EQ(data->run_duration(), run_duration + run_duration);
  EXPECT_EQ(data->queue_duration(), queue_duration + queue_duration);
  EXPECT_EQ(data->AverageMsRunDuration(), run_ms);
  EXPECT_EQ(data->AverageMsQueueDuration(), queue_ms);
  EXPECT_EQ(data->count(), 2);

  scoped_ptr<base::DictionaryValue> dictionary(data->ToValue());
  int integer;
  EXPECT_TRUE(dictionary->GetInteger("run_ms", &integer));
  EXPECT_EQ(integer, 2 * run_ms);
  EXPECT_TRUE(dictionary->GetInteger("queue_ms", &integer));
  EXPECT_EQ(integer, 2* queue_ms);
  EXPECT_TRUE(dictionary->GetInteger("count", &integer));
  EXPECT_EQ(integer, 2);

  std::string output;
  data->WriteHTML(&output);
  std::string results = "Lives:2, Run:84ms(42ms/life) Queue:16ms(8ms/life) ";
  EXPECT_EQ(output, results);

  scoped_ptr<base::Value> value(data->ToValue());
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string birth_only_result = "{\"count\":2,\"queue_ms\":16,\"run_ms\":84}";
  EXPECT_EQ(json, birth_only_result);
}

TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
  if (!ThreadData::StartTracking(true))
    return;
  // We don't initialize system with a thread name, so we're viewed as a worker
  // thread.
  int fake_line_number = 173;
  const char* kFile = "FixedFileName";
  const char* kFunction = "BirthOnlyToValueWorkerThread";
  Location location(kFunction, kFile, fake_line_number, NULL);
  Births* birth = ThreadData::TallyABirthIfActive(location);
  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));

  int process_type = 3;
  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string birth_only_result = "{"
      "\"list\":["
        "{"
          "\"birth_thread\":\"WorkerThread-1\","
          "\"death_data\":{"
            "\"count\":1,"
            "\"queue_ms\":0,"
            "\"run_ms\":0"
          "},"
          "\"death_thread\":\"Still_Alive\","
          "\"location\":{"
            "\"file_name\":\"FixedFileName\","
            "\"function_name\":\"BirthOnlyToValueWorkerThread\","
            "\"line_number\":173"
          "}"
        "}"
      "],"
      "\"process\":3"
    "}";
  EXPECT_EQ(json, birth_only_result);
}

TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
  if (!ThreadData::StartTracking(true))
    return;

  // Use a well named thread.
  ThreadData::InitializeThreadContext("SomeMainThreadName");
  int fake_line_number = 173;
  const char* kFile = "FixedFileName";
  const char* kFunction = "BirthOnlyToValueMainThread";
  Location location(kFunction, kFile, fake_line_number, NULL);
  // Do not delete birth.  We don't own it.
  Births* birth = ThreadData::TallyABirthIfActive(location);
  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));

  int process_type = 34;
  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string birth_only_result = "{"
      "\"list\":["
        "{"
          "\"birth_thread\":\"SomeMainThreadName\","
          "\"death_data\":{"
            "\"count\":1,"
            "\"queue_ms\":0,"
            "\"run_ms\":0"
          "},"
          "\"death_thread\":\"Still_Alive\","
          "\"location\":{"
            "\"file_name\":\"FixedFileName\","
            "\"function_name\":\"BirthOnlyToValueMainThread\","
            "\"line_number\":173"
          "}"
        "}"
      "],"
      "\"process\":34"
    "}";
  EXPECT_EQ(json, birth_only_result);
}

TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
  if (!ThreadData::StartTracking(true))
    return;

  // Use a well named thread.
  ThreadData::InitializeThreadContext("SomeMainThreadName");
  int fake_line_number = 236;
  const char* kFile = "FixedFileName";
  const char* kFunction = "LifeCycleToValueMainThread";
  Location location(kFunction, kFile, fake_line_number, NULL);
  // Do not delete birth.  We don't own it.
  Births* birth = ThreadData::TallyABirthIfActive(location);
  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));

  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
  // milliseconds, so we need to use 1000x.
  const base::TimeTicks time_posted = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(1);
  const base::TimeTicks delayed_start_time = base::TimeTicks();
  const base::TimeTicks start_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(5);
  const base::TimeTicks end_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(7);
  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
                                  start_of_run, end_of_run);

  int process_type = 7;
  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string one_line_result = "{"
      "\"list\":["
        "{"
          "\"birth_thread\":\"SomeMainThreadName\","
          "\"death_data\":{"
            "\"count\":1,"
            "\"queue_ms\":4,"
            "\"run_ms\":2"
          "},"
          "\"death_thread\":\"SomeMainThreadName\","
          "\"location\":{"
            "\"file_name\":\"FixedFileName\","
            "\"function_name\":\"LifeCycleToValueMainThread\","
            "\"line_number\":236"
          "}"
        "}"
      "],"
      "\"process\":7"
    "}";
  EXPECT_EQ(json, one_line_result);
}

TEST_F(TrackedObjectsTest, TwoLives) {
  if (!ThreadData::StartTracking(true))
    return;

  // Use a well named thread.
  ThreadData::InitializeThreadContext("SomeFileThreadName");
  int fake_line_number = 222;
  const char* kFile = "AnotherFileName";
  const char* kFunction = "TwoLives";
  Location location(kFunction, kFile, fake_line_number, NULL);
  // Do not delete birth.  We don't own it.
  Births* birth = ThreadData::TallyABirthIfActive(location);
  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));

  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
  // milliseconds, so we need to use 1000x.
  const base::TimeTicks time_posted = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(1);
  const base::TimeTicks delayed_start_time = base::TimeTicks();
  const base::TimeTicks start_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(5);
  const base::TimeTicks end_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(7);
  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
                                  start_of_run, end_of_run);

  birth = ThreadData::TallyABirthIfActive(location);
  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
                                  start_of_run, end_of_run);

  int process_type = 7;
  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string one_line_result = "{"
      "\"list\":["
        "{"
          "\"birth_thread\":\"SomeFileThreadName\","
          "\"death_data\":{"
            "\"count\":2,"
            "\"queue_ms\":8,"
            "\"run_ms\":4"
          "},"
          "\"death_thread\":\"SomeFileThreadName\","
          "\"location\":{"
            "\"file_name\":\"AnotherFileName\","
            "\"function_name\":\"TwoLives\","
            "\"line_number\":222"
          "}"
        "}"
      "],"
      "\"process\":7"
    "}";
  EXPECT_EQ(json, one_line_result);
}

TEST_F(TrackedObjectsTest, DifferentLives) {
  if (!ThreadData::StartTracking(true))
    return;

  // Use a well named thread.
  ThreadData::InitializeThreadContext("SomeFileThreadName");
  int fake_line_number = 567;
  const char* kFile = "AnotherFileName";
  const char* kFunction = "DifferentLives";
  Location location(kFunction, kFile, fake_line_number, NULL);
  // Do not delete birth.  We don't own it.
  Births* birth = ThreadData::TallyABirthIfActive(location);
  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));

  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
  // milliseconds, so we need to use 1000x.
  const base::TimeTicks time_posted = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(1);
  const base::TimeTicks delayed_start_time = base::TimeTicks();
  const base::TimeTicks start_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(5);
  const base::TimeTicks end_of_run = base::TimeTicks() +
      base::TimeDelta::FromMilliseconds(7);
  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
                                  start_of_run, end_of_run);

  int second_fake_line_number = 999;
  Location second_location(kFunction, kFile, second_fake_line_number, NULL);
  birth = ThreadData::TallyABirthIfActive(second_location);

  int process_type = 2;
  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
  std::string json;
  base::JSONWriter::Write(value.get(), false, &json);
  std::string one_line_result = "{"
      "\"list\":["
        "{"
          "\"birth_thread\":\"SomeFileThreadName\","
          "\"death_data\":{"
            "\"count\":1,"
            "\"queue_ms\":4,"
            "\"run_ms\":2"
          "},"
          "\"death_thread\":\"SomeFileThreadName\","
          "\"location\":{"
            "\"file_name\":\"AnotherFileName\","
            "\"function_name\":\"DifferentLives\","
            "\"line_number\":567"
          "}"
        "},"
        "{"
          "\"birth_thread\":\"SomeFileThreadName\","
          "\"death_data\":{"
            "\"count\":1,"
            "\"queue_ms\":0,"
            "\"run_ms\":0"
          "},"
          "\"death_thread\":\"Still_Alive\","
          "\"location\":{"
            "\"file_name\":\"AnotherFileName\","
            "\"function_name\":\"DifferentLives\","
            "\"line_number\":999"
          "}"
        "}"
      "],"
    "\"process\":2"
    "}";
  EXPECT_EQ(json, one_line_result);
}

}  // namespace tracked_objects