1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// 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 "chrome/common/conflicts/module_watcher_win.h"
#include <windows.h>
#include <memory>
#include "base/functional/bind.h"
#include "base/test/task_environment.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
class ModuleWatcherTest : public testing::Test {
public:
ModuleWatcherTest(const ModuleWatcherTest&) = delete;
ModuleWatcherTest& operator=(const ModuleWatcherTest&) = delete;
protected:
ModuleWatcherTest()
: module_(nullptr),
module_event_count_(0),
module_already_loaded_event_count_(0),
module_loaded_event_count_(0) {}
void OnModuleEvent(const ModuleWatcher::ModuleEvent& event) {
++module_event_count_;
switch (event.event_type) {
case ModuleWatcher::ModuleEventType::kModuleAlreadyLoaded:
++module_already_loaded_event_count_;
break;
case ModuleWatcher::ModuleEventType::kModuleLoaded:
++module_loaded_event_count_;
break;
}
}
void TearDown() override { UnloadModule(); }
void LoadModule() {
if (module_)
return;
// This module should not be a static dependency of the unit-test
// executable, but should be a build-system dependency or a module that is
// present on any Windows machine.
static constexpr wchar_t kModuleName[] = L"conflicts_dll.dll";
// The module should not already be loaded.
ASSERT_FALSE(::GetModuleHandle(kModuleName));
// It should load successfully.
module_ = ::LoadLibrary(kModuleName);
ASSERT_TRUE(module_);
}
void UnloadModule() {
if (!module_)
return;
::FreeLibrary(module_);
module_ = nullptr;
}
void RunUntilIdle() { task_environment_.RunUntilIdle(); }
std::unique_ptr<ModuleWatcher> Create() {
return ModuleWatcher::Create(base::BindRepeating(
&ModuleWatcherTest::OnModuleEvent, base::Unretained(this)));
}
base::test::TaskEnvironment task_environment_;
// Holds a handle to a loaded module.
HMODULE module_;
// Total number of module events seen.
int module_event_count_;
// Total number of MODULE_ALREADY_LOADED events seen.
int module_already_loaded_event_count_;
// Total number of MODULE_LOADED events seen.
int module_loaded_event_count_;
};
TEST_F(ModuleWatcherTest, SingleModuleWatcherOnly) {
std::unique_ptr<ModuleWatcher> mw1(Create());
EXPECT_TRUE(mw1.get());
std::unique_ptr<ModuleWatcher> mw2(Create());
EXPECT_FALSE(mw2.get());
}
// TODO: crbug.com/347201817 - Fix ODR violation.
#if BUILDFLAG(IS_WIN) && defined(ADDRESS_SANITIZER)
#define MAYBE_ModuleEvents DISABLED_ModuleEvents
#else
#define MAYBE_ModuleEvents ModuleEvents
#endif
TEST_F(ModuleWatcherTest, MAYBE_ModuleEvents) {
// Create the module watcher. This should immediately enumerate all already
// loaded modules on a background task.
std::unique_ptr<ModuleWatcher> mw(Create());
RunUntilIdle();
EXPECT_LT(0, module_event_count_);
EXPECT_LT(0, module_already_loaded_event_count_);
EXPECT_EQ(0, module_loaded_event_count_);
// Dynamically load a module and ensure a notification is received for it.
int previous_module_loaded_event_count = module_loaded_event_count_;
LoadModule();
EXPECT_LT(previous_module_loaded_event_count, module_loaded_event_count_);
UnloadModule();
// Dynamically load a module and ensure a notification is received for it.
previous_module_loaded_event_count = module_loaded_event_count_;
LoadModule();
EXPECT_LT(previous_module_loaded_event_count, module_loaded_event_count_);
UnloadModule();
// Destroy the module watcher.
mw.reset();
// Load the module and ensure no notification is received this time.
previous_module_loaded_event_count = module_loaded_event_count_;
LoadModule();
EXPECT_EQ(previous_module_loaded_event_count, module_loaded_event_count_);
}
|
