129 lines
3.5 KiB
C++
129 lines
3.5 KiB
C++
// 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
|