| // Copyright 2013 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/android/activity_status.h" |
| #include "base/bind.h" |
| #include "base/callback_forward.h" |
| #include "base/logging.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/message_loop/message_loop_proxy.h" |
| #include "base/run_loop.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/threading/thread.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace base { |
| namespace android { |
| |
| namespace { |
| |
| using base::android::ScopedJavaLocalRef; |
| |
| // An invalid ActivityState value. |
| const ActivityState kInvalidActivityState = static_cast<ActivityState>(100); |
| |
| // Used to generate a callback that stores the new state at a given location. |
| void StoreStateTo(ActivityState* target, ActivityState state) { |
| *target = state; |
| } |
| |
| void RunTasksUntilIdle() { |
| RunLoop run_loop; |
| run_loop.RunUntilIdle(); |
| } |
| |
| // Shared state for the multi-threaded test. |
| // This uses a thread to register for events and listen to them, while state |
| // changes are forced on the main thread. |
| class MultiThreadedTest { |
| public: |
| MultiThreadedTest() |
| : activity_status_(ActivityStatus::GetInstance()), |
| state_(kInvalidActivityState), |
| event_(false, false), |
| thread_("ActivityStatusTest thread"), |
| main_() { |
| } |
| |
| void Run() { |
| // Start the thread and tell it to register for events. |
| thread_.Start(); |
| thread_.message_loop() |
| ->PostTask(FROM_HERE, |
| base::Bind(&MultiThreadedTest::RegisterThreadForEvents, |
| base::Unretained(this))); |
| |
| // Wait for its completion. |
| event_.Wait(); |
| |
| // Change state, then wait for the thread to modify state. |
| activity_status_->OnActivityStateChange(ACTIVITY_STATE_CREATED); |
| event_.Wait(); |
| EXPECT_EQ(ACTIVITY_STATE_CREATED, state_); |
| |
| // Again |
| activity_status_->OnActivityStateChange(ACTIVITY_STATE_DESTROYED); |
| event_.Wait(); |
| EXPECT_EQ(ACTIVITY_STATE_DESTROYED, state_); |
| } |
| |
| private: |
| void ExpectOnThread() { |
| EXPECT_EQ(thread_.message_loop(), base::MessageLoop::current()); |
| } |
| |
| void RegisterThreadForEvents() { |
| ExpectOnThread(); |
| listener_.reset(new ActivityStatus::Listener(base::Bind( |
| &MultiThreadedTest::StoreStateAndSignal, base::Unretained(this)))); |
| EXPECT_TRUE(listener_.get()); |
| event_.Signal(); |
| } |
| |
| void StoreStateAndSignal(ActivityState state) { |
| ExpectOnThread(); |
| state_ = state; |
| event_.Signal(); |
| } |
| |
| ActivityStatus* const activity_status_; |
| ActivityState state_; |
| base::WaitableEvent event_; |
| base::Thread thread_; |
| base::MessageLoop main_; |
| scoped_ptr<ActivityStatus::Listener> listener_; |
| }; |
| |
| } // namespace |
| |
| TEST(ActivityStatusTest, SingleThread) { |
| MessageLoop message_loop; |
| |
| ActivityState result = kInvalidActivityState; |
| |
| // Create a new listener that stores the new state into |result| on every |
| // state change. |
| ActivityStatus::Listener listener( |
| base::Bind(&StoreStateTo, base::Unretained(&result))); |
| |
| EXPECT_EQ(kInvalidActivityState, result); |
| |
| ActivityStatus* const activity_status = ActivityStatus::GetInstance(); |
| activity_status->OnActivityStateChange(ACTIVITY_STATE_CREATED); |
| RunTasksUntilIdle(); |
| EXPECT_EQ(ACTIVITY_STATE_CREATED, result); |
| |
| activity_status->OnActivityStateChange(ACTIVITY_STATE_DESTROYED); |
| RunTasksUntilIdle(); |
| EXPECT_EQ(ACTIVITY_STATE_DESTROYED, result); |
| } |
| |
| TEST(ActivityStatusTest, TwoThreads) { |
| MultiThreadedTest test; |
| test.Run(); |
| } |
| |
| } // namespace android |
| } // namespace base |