services/media/framework/test/incident_test.cc - Issue 2024953003: Motown: Move framework/util/incident* so other services can use it

Side by Side Diff: services/media/framework/test/incident_test.cc

Issue 2024953003: Motown: Move framework/util/incident* so other services can use it (Closed) Base URL: https://github.com/domokit/mojo.git@master

Patch Set: Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 // Copyright 2016 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "services/media/framework/test/test_base.h"

6 #include "services/media/framework/util/incident.h"

7

8 namespace mojo {

9 namespace media {

10 namespace {

11

12 class IncidentTest : public TestBase {};

13

14 // Tests whether Incident::Occur and Incident::Reset have the right effect on

15 // Incident::occurred.

16 TEST_F(IncidentTest, Basics) {

17 Incident under_test;

18

19 EXPECT_FALSE(under_test.occurred());

20

21 under_test.Occur();

22 EXPECT_TRUE(under_test.occurred());

23

24 under_test.Reset();

25 EXPECT_FALSE(under_test.occurred());

26

27 // Incident::Run does the same thing as Incident::Occur.

28 under_test.Run();

29 EXPECT_TRUE(under_test.occurred());

30

31 under_test.Reset();

32 EXPECT_FALSE(under_test.occurred());

33 }

34

35 // Tests whether a consequence registered with Incident::When runs only after

36 // Incident::Occur is called.

37 TEST_F(IncidentTest, When_Delayed) {

38 Incident under_test;

39

40 // These two together should be a no-op.

41 under_test.Occur();

42 under_test.Reset();

43

44 bool consequence_ran = false;

45 under_test.When([&consequence_ran]() { consequence_ran = true; });

46 EXPECT_FALSE(consequence_ran);

47

48 under_test.Occur();

49 EXPECT_TRUE(consequence_ran);

50 }

51

52 // Tests whether a consequence registered with Incident::When runs immediately

53 // when Incident::Occur was called first.

54 TEST_F(IncidentTest, When_Immediate) {

55 Incident under_test;

56

57 under_test.Occur();

58

59 bool consequence_ran = false;

60 under_test.When([&consequence_ran]() { consequence_ran = true; });

61 EXPECT_TRUE(consequence_ran);

62 }

63

64 // Tests whether a consequence registered with Incident::When runs

65 // Incident::Reset is called before Incident::Occur (it shouldn't).

66 TEST_F(IncidentTest, When_Reset) {

67 Incident under_test;

68

69 bool consequence_ran = false;

70 under_test.When([&consequence_ran]() { consequence_ran = true; });

71 EXPECT_FALSE(consequence_ran);

72

73 under_test.Reset();

74 EXPECT_FALSE(consequence_ran);

75

76 under_test.Occur();

77 EXPECT_FALSE(consequence_ran);

78 }

79

80 // Tests whether a consequences registered with Incident::When run in the

81 // correct order.

82 TEST_F(IncidentTest, When_Order) {

83 Incident under_test;

84 int sequence_counter = 0;

85

86 under_test.When([&sequence_counter]() { EXPECT_EQ(0, sequence_counter++); });

87 under_test.When([&sequence_counter]() { EXPECT_EQ(1, sequence_counter++); });

88 under_test.When([&sequence_counter]() { EXPECT_EQ(2, sequence_counter++); });

89 under_test.When([&sequence_counter]() { EXPECT_EQ(3, sequence_counter++); });

90

91 under_test.Occur();

92

93 under_test.When([&sequence_counter]() { EXPECT_EQ(4, sequence_counter++); });

94 under_test.When([&sequence_counter]() { EXPECT_EQ(5, sequence_counter++); });

95 under_test.When([&sequence_counter]() { EXPECT_EQ(6, sequence_counter++); });

96 under_test.When([&sequence_counter]() { EXPECT_EQ(7, sequence_counter++); });

97

98 EXPECT_EQ(8, sequence_counter);

99 }

100

101 // Tests whether a consequence registered with Incident::When runs when

102 // Incident::Occur is never called and the Incident is deleted (it shouldn't).

103 TEST_F(IncidentTest, When_After_Delete) {

104 bool consequence_ran = false;

105

106 {

107 Incident under_test;

108 under_test.When([&consequence_ran]() { consequence_ran = true; });

109 }

110

111 EXPECT_FALSE(consequence_ran);

112 }

113

114 class ThreadsafeIncidentTest : public TestBase {};

115

116 // Tests whether ThreadsafeIncident::Occur and ThreadsafeIncident::Reset have

117 // the right effect on ThreadsafeIncident::occurred.

118 TEST_F(ThreadsafeIncidentTest, Basics) {

119 ThreadsafeIncident under_test;

120

121 EXPECT_FALSE(under_test.occurred());

122

123 under_test.Occur();

124 EXPECT_TRUE(under_test.occurred());

125

126 under_test.Reset();

127 EXPECT_FALSE(under_test.occurred());

128

129 // ThreadsafeIncident::Run does the same thing as ThreadsafeIncident::Occur.

130 under_test.Run();

131 EXPECT_TRUE(under_test.occurred());

132

133 under_test.Reset();

134 EXPECT_FALSE(under_test.occurred());

135 }

136

137 // Tests whether a consequence registered with ThreadsafeIncident::When runs

138 // only after ThreadsafeIncident::Occur is called.

139 TEST_F(ThreadsafeIncidentTest, When_Delayed) {

140 ThreadsafeIncident under_test;

141

142 // These two together should be a no-op.

143 under_test.Occur();

144 under_test.Reset();

145

146 bool consequence_ran = false;

147 under_test.When([&consequence_ran]() { consequence_ran = true; });

148 EXPECT_FALSE(consequence_ran);

149

150 under_test.Occur();

151 EXPECT_TRUE(consequence_ran);

152 }

153

154 // Tests whether a consequence registered with ThreadsafeIncident::When runs

155 // immediately when ThreadsafeIncident::Occur was called first.

156 TEST_F(ThreadsafeIncidentTest, When_Immediate) {

157 ThreadsafeIncident under_test;

158

159 under_test.Occur();

160

161 bool consequence_ran = false;

162 under_test.When([&consequence_ran]() { consequence_ran = true; });

163 EXPECT_TRUE(consequence_ran);

164 }

165

166 // Tests whether a consequence registered with ThreadsafeIncident::When runs

167 // ThreadsafeIncident::Reset is called before ThreadsafeIncident::Occur (it

168 // shouldn't).

169 TEST_F(ThreadsafeIncidentTest, When_Reset) {

170 ThreadsafeIncident under_test;

171

172 bool consequence_ran = false;

173 under_test.When([&consequence_ran]() { consequence_ran = true; });

174 EXPECT_FALSE(consequence_ran);

175

176 under_test.Reset();

177 EXPECT_FALSE(consequence_ran);

178

179 under_test.Occur();

180 EXPECT_FALSE(consequence_ran);

181 }

182

183 // Tests whether a consequences registered with ThreadsafeIncident::When run in

184 // the correct order.

185 TEST_F(ThreadsafeIncidentTest, When_Order) {

186 ThreadsafeIncident under_test;

187 int sequence_counter = 0;

188

189 under_test.When([&sequence_counter]() { EXPECT_EQ(0, sequence_counter++); });

190 under_test.When([&sequence_counter]() { EXPECT_EQ(1, sequence_counter++); });

191 under_test.When([&sequence_counter]() { EXPECT_EQ(2, sequence_counter++); });

192 under_test.When([&sequence_counter]() { EXPECT_EQ(3, sequence_counter++); });

193

194 under_test.Occur();

195

196 under_test.When([&sequence_counter]() { EXPECT_EQ(4, sequence_counter++); });

197 under_test.When([&sequence_counter]() { EXPECT_EQ(5, sequence_counter++); });

198 under_test.When([&sequence_counter]() { EXPECT_EQ(6, sequence_counter++); });

199 under_test.When([&sequence_counter]() { EXPECT_EQ(7, sequence_counter++); });

200

201 EXPECT_EQ(8, sequence_counter);

202 }

203

204 // Tests whether a consequence registered with ThreadsafeIncident::When runs

205 // when ThreadsafeIncident::Occur is never called and the ThreadsafeIncident is

206 // deleted (it shouldn't).

207 TEST_F(ThreadsafeIncidentTest, When_After_Delete) {

208 bool consequence_ran = false;

209

210 {

211 ThreadsafeIncident under_test;

212 under_test.When([&consequence_ran]() { consequence_ran = true; });

213 }

214

215 EXPECT_FALSE(consequence_ran);

216 }

217

218 } // namespace

219 } // namespace media

220 } // namespace mojo

OLD	NEW

« no previous file with comments | « services/media/framework/parts/reader_cache.h ('k') | services/media/framework/util/incident.h » ('j') | services/util/cpp/test/test_base.h » ('J')