blob: bf293c7711f56c44fabe7b5c8d335858dd2ab8dd [file] [log] [blame]
// Copyright (c) 2012 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.
#include "base/at_exit.h"
#include "base/atomic_sequence_num.h"
#include "base/lazy_instance.h"
#include "base/memory/aligned_memory.h"
#include "base/threading/simple_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
base::StaticAtomicSequenceNumber constructed_seq_;
base::StaticAtomicSequenceNumber destructed_seq_;
class ConstructAndDestructLogger {
public:
ConstructAndDestructLogger() {
constructed_seq_.GetNext();
}
~ConstructAndDestructLogger() {
destructed_seq_.GetNext();
}
};
class SlowConstructor {
public:
SlowConstructor() : some_int_(0) {
// Sleep for 1 second to try to cause a race.
base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
++constructed;
some_int_ = 12;
}
int some_int() const { return some_int_; }
static int constructed;
private:
int some_int_;
};
int SlowConstructor::constructed = 0;
class SlowDelegate : public base::DelegateSimpleThread::Delegate {
public:
explicit SlowDelegate(base::LazyInstance<SlowConstructor>* lazy)
: lazy_(lazy) {}
virtual void Run() override {
EXPECT_EQ(12, lazy_->Get().some_int());
EXPECT_EQ(12, lazy_->Pointer()->some_int());
}
private:
base::LazyInstance<SlowConstructor>* lazy_;
};
} // namespace
static base::LazyInstance<ConstructAndDestructLogger> lazy_logger =
LAZY_INSTANCE_INITIALIZER;
TEST(LazyInstanceTest, Basic) {
{
base::ShadowingAtExitManager shadow;
EXPECT_EQ(0, constructed_seq_.GetNext());
EXPECT_EQ(0, destructed_seq_.GetNext());
lazy_logger.Get();
EXPECT_EQ(2, constructed_seq_.GetNext());
EXPECT_EQ(1, destructed_seq_.GetNext());
lazy_logger.Pointer();
EXPECT_EQ(3, constructed_seq_.GetNext());
EXPECT_EQ(2, destructed_seq_.GetNext());
}
EXPECT_EQ(4, constructed_seq_.GetNext());
EXPECT_EQ(4, destructed_seq_.GetNext());
}
static base::LazyInstance<SlowConstructor> lazy_slow =
LAZY_INSTANCE_INITIALIZER;
TEST(LazyInstanceTest, ConstructorThreadSafety) {
{
base::ShadowingAtExitManager shadow;
SlowDelegate delegate(&lazy_slow);
EXPECT_EQ(0, SlowConstructor::constructed);
base::DelegateSimpleThreadPool pool("lazy_instance_cons", 5);
pool.AddWork(&delegate, 20);
EXPECT_EQ(0, SlowConstructor::constructed);
pool.Start();
pool.JoinAll();
EXPECT_EQ(1, SlowConstructor::constructed);
}
}
namespace {
// DeleteLogger is an object which sets a flag when it's destroyed.
// It accepts a bool* and sets the bool to true when the dtor runs.
class DeleteLogger {
public:
DeleteLogger() : deleted_(NULL) {}
~DeleteLogger() { *deleted_ = true; }
void SetDeletedPtr(bool* deleted) {
deleted_ = deleted;
}
private:
bool* deleted_;
};
} // anonymous namespace
TEST(LazyInstanceTest, LeakyLazyInstance) {
// Check that using a plain LazyInstance causes the dtor to run
// when the AtExitManager finishes.
bool deleted1 = false;
{
base::ShadowingAtExitManager shadow;
static base::LazyInstance<DeleteLogger> test = LAZY_INSTANCE_INITIALIZER;
test.Get().SetDeletedPtr(&deleted1);
}
EXPECT_TRUE(deleted1);
// Check that using a *leaky* LazyInstance makes the dtor not run
// when the AtExitManager finishes.
bool deleted2 = false;
{
base::ShadowingAtExitManager shadow;
static base::LazyInstance<DeleteLogger>::Leaky
test = LAZY_INSTANCE_INITIALIZER;
test.Get().SetDeletedPtr(&deleted2);
}
EXPECT_FALSE(deleted2);
}
namespace {
template <size_t alignment>
class AlignedData {
public:
AlignedData() {}
~AlignedData() {}
base::AlignedMemory<alignment, alignment> data_;
};
} // anonymous namespace
#define EXPECT_ALIGNED(ptr, align) \
EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
TEST(LazyInstanceTest, Alignment) {
using base::LazyInstance;
// Create some static instances with increasing sizes and alignment
// requirements. By ordering this way, the linker will need to do some work to
// ensure proper alignment of the static data.
static LazyInstance<AlignedData<4> > align4 = LAZY_INSTANCE_INITIALIZER;
static LazyInstance<AlignedData<32> > align32 = LAZY_INSTANCE_INITIALIZER;
static LazyInstance<AlignedData<4096> > align4096 = LAZY_INSTANCE_INITIALIZER;
EXPECT_ALIGNED(align4.Pointer(), 4);
EXPECT_ALIGNED(align32.Pointer(), 32);
EXPECT_ALIGNED(align4096.Pointer(), 4096);
}