// Copyright 2017 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/threading/sequence_local_storage_slot.h"
|
|
#include <utility>
|
|
#include "base/macros.h"
|
#include "base/memory/ptr_util.h"
|
#include "base/threading/sequence_local_storage_map.h"
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
namespace base {
|
|
namespace {
|
|
class SequenceLocalStorageSlotTest : public testing::Test {
|
protected:
|
SequenceLocalStorageSlotTest()
|
: scoped_sequence_local_storage_(&sequence_local_storage_) {}
|
|
internal::SequenceLocalStorageMap sequence_local_storage_;
|
internal::ScopedSetSequenceLocalStorageMapForCurrentThread
|
scoped_sequence_local_storage_;
|
|
private:
|
DISALLOW_COPY_AND_ASSIGN(SequenceLocalStorageSlotTest);
|
};
|
|
} // namespace
|
|
// Verify that a value stored with Set() can be retrieved with Get().
|
TEST_F(SequenceLocalStorageSlotTest, GetSet) {
|
SequenceLocalStorageSlot<int> slot;
|
slot.Set(5);
|
EXPECT_EQ(slot.Get(), 5);
|
}
|
|
// Verify that setting an object in a SequenceLocalStorageSlot creates a copy
|
// of that object independent of the original one.
|
TEST_F(SequenceLocalStorageSlotTest, SetObjectIsIndependent) {
|
bool should_be_false = false;
|
|
SequenceLocalStorageSlot<bool> slot;
|
|
slot.Set(should_be_false);
|
|
EXPECT_FALSE(slot.Get());
|
slot.Get() = true;
|
EXPECT_TRUE(slot.Get());
|
|
EXPECT_NE(should_be_false, slot.Get());
|
}
|
|
// Verify that multiple slots work and that calling Get after overwriting
|
// a value in a slot yields the new value.
|
TEST_F(SequenceLocalStorageSlotTest, GetSetMultipleSlots) {
|
SequenceLocalStorageSlot<int> slot1;
|
SequenceLocalStorageSlot<int> slot2;
|
SequenceLocalStorageSlot<int> slot3;
|
|
slot1.Set(1);
|
slot2.Set(2);
|
slot3.Set(3);
|
|
EXPECT_EQ(slot1.Get(), 1);
|
EXPECT_EQ(slot2.Get(), 2);
|
EXPECT_EQ(slot3.Get(), 3);
|
|
slot3.Set(4);
|
slot2.Set(5);
|
slot1.Set(6);
|
|
EXPECT_EQ(slot3.Get(), 4);
|
EXPECT_EQ(slot2.Get(), 5);
|
EXPECT_EQ(slot1.Get(), 6);
|
}
|
|
// Verify that changing the the value returned by Get() changes the value
|
// in sequence local storage.
|
TEST_F(SequenceLocalStorageSlotTest, GetReferenceModifiable) {
|
SequenceLocalStorageSlot<bool> slot;
|
slot.Set(false);
|
slot.Get() = true;
|
EXPECT_TRUE(slot.Get());
|
}
|
|
// Verify that a move-only type can be stored in sequence local storage.
|
TEST_F(SequenceLocalStorageSlotTest, SetGetWithMoveOnlyType) {
|
std::unique_ptr<int> int_unique_ptr = std::make_unique<int>(5);
|
|
SequenceLocalStorageSlot<std::unique_ptr<int>> slot;
|
slot.Set(std::move(int_unique_ptr));
|
|
EXPECT_EQ(*slot.Get(), 5);
|
}
|
|
// Verify that a Get() without a previous Set() on a slot returns a
|
// default-constructed value.
|
TEST_F(SequenceLocalStorageSlotTest, GetWithoutSetDefaultConstructs) {
|
struct DefaultConstructable {
|
int x = 0x12345678;
|
};
|
|
SequenceLocalStorageSlot<DefaultConstructable> slot;
|
|
EXPECT_EQ(slot.Get().x, 0x12345678);
|
}
|
|
// Verify that a Get() without a previous Set() on a slot with a POD-type
|
// returns a default-constructed value.
|
// Note: this test could be flaky and give a false pass. If it's flaky, the test
|
// might've "passed" because the memory for the slot happened to be zeroed.
|
TEST_F(SequenceLocalStorageSlotTest, GetWithoutSetDefaultConstructsPOD) {
|
SequenceLocalStorageSlot<void*> slot;
|
|
EXPECT_EQ(slot.Get(), nullptr);
|
}
|
|
// Verify that the value of a slot is specific to a SequenceLocalStorageMap
|
TEST(SequenceLocalStorageSlotMultipleMapTest, SetGetMultipleMapsOneSlot) {
|
SequenceLocalStorageSlot<unsigned int> slot;
|
internal::SequenceLocalStorageMap sequence_local_storage_maps[5];
|
|
// Set the value of the slot to be the index of the current
|
// SequenceLocalStorageMaps in the vector
|
for (unsigned int i = 0; i < arraysize(sequence_local_storage_maps); ++i) {
|
internal::ScopedSetSequenceLocalStorageMapForCurrentThread
|
scoped_sequence_local_storage(&sequence_local_storage_maps[i]);
|
|
slot.Set(i);
|
}
|
|
for (unsigned int i = 0; i < arraysize(sequence_local_storage_maps); ++i) {
|
internal::ScopedSetSequenceLocalStorageMapForCurrentThread
|
scoped_sequence_local_storage(&sequence_local_storage_maps[i]);
|
|
EXPECT_EQ(slot.Get(), i);
|
}
|
}
|
|
} // namespace base
|
