| // Copyright 2016 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include"base/sequence_token.h" |
| |
| #include"testing/gtest/include/gtest/gtest.h" |
| |
| namespace base::internal{ |
| |
| TEST(SequenceTokenTest,IsValid){ |
| EXPECT_FALSE(SequenceToken().IsValid()); |
| EXPECT_TRUE(SequenceToken::Create().IsValid()); |
| } |
| |
| TEST(SequenceTokenTest,OperatorEquals){ |
| constSequenceToken invalid_a; |
| constSequenceToken invalid_b; |
| constSequenceToken valid_a=SequenceToken::Create(); |
| constSequenceToken valid_b=SequenceToken::Create(); |
| |
| EXPECT_FALSE(invalid_a== invalid_a); |
| EXPECT_FALSE(invalid_a== invalid_b); |
| EXPECT_FALSE(invalid_a== valid_a); |
| EXPECT_FALSE(invalid_a== valid_b); |
| |
| EXPECT_FALSE(valid_a== invalid_a); |
| EXPECT_FALSE(valid_a== invalid_b); |
| EXPECT_EQ(valid_a, valid_a); |
| EXPECT_FALSE(valid_a== valid_b); |
| } |
| |
| TEST(SequenceTokenTest,OperatorNotEquals){ |
| constSequenceToken invalid_a; |
| constSequenceToken invalid_b; |
| constSequenceToken valid_a=SequenceToken::Create(); |
| constSequenceToken valid_b=SequenceToken::Create(); |
| |
| EXPECT_NE(invalid_a, invalid_a); |
| EXPECT_NE(invalid_a, invalid_b); |
| EXPECT_NE(invalid_a, valid_a); |
| EXPECT_NE(invalid_a, valid_b); |
| |
| EXPECT_NE(valid_a, invalid_a); |
| EXPECT_NE(valid_a, invalid_b); |
| EXPECT_FALSE(valid_a!= valid_a); |
| EXPECT_NE(valid_a, valid_b); |
| } |
| |
| TEST(SequenceTokenTest,GetForCurrentThread){ |
| constSequenceToken token=SequenceToken::Create(); |
| |
| EXPECT_TRUE(SequenceToken::GetForCurrentThread().IsValid()); |
| |
| { |
| TaskScope task_scope(token,/* is_thread_bound=*/false); |
| EXPECT_TRUE(SequenceToken::GetForCurrentThread().IsValid()); |
| EXPECT_EQ(token,SequenceToken::GetForCurrentThread()); |
| } |
| |
| EXPECT_TRUE(SequenceToken::GetForCurrentThread().IsValid()); |
| } |
| |
| TEST(SequenceTokenTest,ToInternalValue){ |
| constSequenceToken token1=SequenceToken::Create(); |
| constSequenceToken token2=SequenceToken::Create(); |
| |
| // Confirm that internal values are unique. |
| EXPECT_NE(token1.ToInternalValue(), token2.ToInternalValue()); |
| } |
| |
| // Expect a default-constructed TaskToken to be invalid and not equal to |
| // another invalid TaskToken. |
| TEST(TaskTokenTest,InvalidDefaultConstructed){ |
| EXPECT_FALSE(TaskToken().IsValid()); |
| EXPECT_NE(TaskToken(),TaskToken()); |
| } |
| |
| // Expect a TaskToken returned by TaskToken::GetForCurrentThread() outside the |
| // scope of a TaskScope to be invalid. |
| TEST(TaskTokenTest,InvalidOutsideScope){ |
| EXPECT_FALSE(TaskToken::GetForCurrentThread().IsValid()); |
| } |
| |
| // Expect an invalid TaskToken not to be equal with a valid TaskToken. |
| TEST(TaskTokenTest,ValidNotEqualsInvalid){ |
| TaskScope task_scope(SequenceToken::Create(), |
| /* is_thread_bound=*/false); |
| TaskToken valid=TaskToken::GetForCurrentThread(); |
| TaskToken invalid; |
| EXPECT_NE(valid, invalid); |
| } |
| |
| // Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope |
| // of the same TaskScope instance to be |
| // valid and equal with each other. |
| TEST(TaskTokenTest,EqualInSameScope){ |
| TaskScope task_scope(SequenceToken::Create(), |
| /* is_thread_bound=*/false); |
| |
| constTaskToken token_a=TaskToken::GetForCurrentThread(); |
| constTaskToken token_b=TaskToken::GetForCurrentThread(); |
| |
| EXPECT_TRUE(token_a.IsValid()); |
| EXPECT_TRUE(token_b.IsValid()); |
| EXPECT_EQ(token_a, token_b); |
| } |
| |
| // Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope |
| // of different TaskScope instances to be |
| // valid but not equal to each other. |
| TEST(TaskTokenTest,NotEqualInDifferentScopes){ |
| TaskToken token_a; |
| TaskToken token_b; |
| |
| { |
| TaskScope task_scope(SequenceToken::Create(), |
| /* is_thread_bound=*/false); |
| token_a=TaskToken::GetForCurrentThread(); |
| } |
| { |
| TaskScope task_scope(SequenceToken::Create(), |
| /* is_thread_bound=*/false); |
| token_b=TaskToken::GetForCurrentThread(); |
| } |
| |
| EXPECT_TRUE(token_a.IsValid()); |
| EXPECT_TRUE(token_b.IsValid()); |
| EXPECT_NE(token_a, token_b); |
| } |
| |
| TEST(TaskScopeTest,ThreadBound){ |
| // Code running outside of a `TaskScope` is thread-bound. |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| |
| { |
| TaskScope scope(SequenceToken::Create(),/* is_thread_bound=*/false); |
| EXPECT_FALSE(CurrentTaskIsThreadBound()); |
| { |
| TaskScope inner_scope(SequenceToken::Create(),/* is_thread_bound=*/true); |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| } |
| EXPECT_FALSE(CurrentTaskIsThreadBound()); |
| } |
| |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| |
| { |
| TaskScope scope(SequenceToken::Create(),/* is_thread_bound=*/true); |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| { |
| TaskScope inner_scope(SequenceToken::Create(), |
| /* is_thread_bound=*/false); |
| EXPECT_FALSE(CurrentTaskIsThreadBound()); |
| } |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| } |
| |
| EXPECT_TRUE(CurrentTaskIsThreadBound()); |
| } |
| |
| }// namespace base::internal |
