OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/host/heartbeat_sender.h" | 5 #include "remoting/host/heartbeat_sender.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "base/memory/ref_counted.h" | 9 #include "base/memory/ref_counted.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
94 MockSignalStrategy signal_strategy_; | 94 MockSignalStrategy signal_strategy_; |
95 MockClosure mock_heartbeat_successful_callback_; | 95 MockClosure mock_heartbeat_successful_callback_; |
96 MockClosure mock_unknown_host_id_error_callback_; | 96 MockClosure mock_unknown_host_id_error_callback_; |
97 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; | 97 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; |
98 scoped_refptr<RsaKeyPair> key_pair_; | 98 scoped_refptr<RsaKeyPair> key_pair_; |
99 scoped_ptr<HeartbeatSender> heartbeat_sender_; | 99 scoped_ptr<HeartbeatSender> heartbeat_sender_; |
100 }; | 100 }; |
101 | 101 |
102 // Call Start() followed by Stop(), and make sure a valid heartbeat is sent. | 102 // Call Start() followed by Stop(), and make sure a valid heartbeat is sent. |
103 TEST_F(HeartbeatSenderTest, DoSendStanza) { | 103 TEST_F(HeartbeatSenderTest, DoSendStanza) { |
104 XmlElement* sent_iq = NULL; | 104 XmlElement* sent_iq = nullptr; |
105 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 105 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
106 .WillRepeatedly(Return(kTestJid)); | 106 .WillRepeatedly(Return(kTestJid)); |
107 EXPECT_CALL(signal_strategy_, GetNextId()) | 107 EXPECT_CALL(signal_strategy_, GetNextId()) |
108 .WillOnce(Return(kStanzaId)); | 108 .WillOnce(Return(kStanzaId)); |
109 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 109 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
110 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 110 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
111 EXPECT_CALL(signal_strategy_, GetState()) | 111 EXPECT_CALL(signal_strategy_, GetState()) |
112 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 112 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
113 | 113 |
114 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 114 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
115 base::RunLoop().RunUntilIdle(); | 115 base::RunLoop().RunUntilIdle(); |
116 | 116 |
117 scoped_ptr<XmlElement> stanza(sent_iq); | 117 scoped_ptr<XmlElement> stanza(sent_iq); |
118 ASSERT_TRUE(stanza != NULL); | 118 ASSERT_TRUE(stanza != nullptr); |
119 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 119 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
120 | 120 |
121 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 121 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
122 base::RunLoop().RunUntilIdle(); | 122 base::RunLoop().RunUntilIdle(); |
123 } | 123 } |
124 | 124 |
125 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats | 125 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats |
126 // are sent, with the correct sequence IDs. | 126 // are sent, with the correct sequence IDs. |
127 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { | 127 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { |
128 XmlElement* sent_iq = NULL; | 128 XmlElement* sent_iq = nullptr; |
129 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 129 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
130 .WillRepeatedly(Return(kTestJid)); | 130 .WillRepeatedly(Return(kTestJid)); |
131 EXPECT_CALL(signal_strategy_, GetNextId()) | 131 EXPECT_CALL(signal_strategy_, GetNextId()) |
132 .WillOnce(Return(kStanzaId)); | 132 .WillOnce(Return(kStanzaId)); |
133 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 133 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
134 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 134 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
135 EXPECT_CALL(signal_strategy_, GetState()) | 135 EXPECT_CALL(signal_strategy_, GetState()) |
136 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 136 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
137 | 137 |
138 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 138 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
139 base::RunLoop().RunUntilIdle(); | 139 base::RunLoop().RunUntilIdle(); |
140 | 140 |
141 scoped_ptr<XmlElement> stanza(sent_iq); | 141 scoped_ptr<XmlElement> stanza(sent_iq); |
142 ASSERT_TRUE(stanza != NULL); | 142 ASSERT_TRUE(stanza != nullptr); |
143 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 143 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
144 | 144 |
145 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 145 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
146 base::RunLoop().RunUntilIdle(); | 146 base::RunLoop().RunUntilIdle(); |
147 | 147 |
148 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 148 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
149 .WillRepeatedly(Return(kTestJid)); | 149 .WillRepeatedly(Return(kTestJid)); |
150 EXPECT_CALL(signal_strategy_, GetNextId()) | 150 EXPECT_CALL(signal_strategy_, GetNextId()) |
151 .WillOnce(Return(kStanzaId + 1)); | 151 .WillOnce(Return(kStanzaId + 1)); |
152 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 152 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
153 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 153 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
154 | 154 |
155 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 155 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
156 base::RunLoop().RunUntilIdle(); | 156 base::RunLoop().RunUntilIdle(); |
157 | 157 |
158 scoped_ptr<XmlElement> stanza2(sent_iq); | 158 scoped_ptr<XmlElement> stanza2(sent_iq); |
159 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); | 159 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); |
160 | 160 |
161 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 161 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
162 base::RunLoop().RunUntilIdle(); | 162 base::RunLoop().RunUntilIdle(); |
163 } | 163 } |
164 | 164 |
165 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent, | 165 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent, |
166 // reply with an expected sequence ID, and make sure two valid heartbeats | 166 // reply with an expected sequence ID, and make sure two valid heartbeats |
167 // are sent, with the correct sequence IDs. | 167 // are sent, with the correct sequence IDs. |
168 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { | 168 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { |
169 XmlElement* sent_iq = NULL; | 169 XmlElement* sent_iq = nullptr; |
170 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 170 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
171 .WillRepeatedly(Return(kTestJid)); | 171 .WillRepeatedly(Return(kTestJid)); |
172 EXPECT_CALL(signal_strategy_, GetNextId()) | 172 EXPECT_CALL(signal_strategy_, GetNextId()) |
173 .WillOnce(Return(kStanzaId)); | 173 .WillOnce(Return(kStanzaId)); |
174 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 174 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
175 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 175 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
176 EXPECT_CALL(signal_strategy_, GetState()) | 176 EXPECT_CALL(signal_strategy_, GetState()) |
177 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 177 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
178 | 178 |
179 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 179 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
180 base::RunLoop().RunUntilIdle(); | 180 base::RunLoop().RunUntilIdle(); |
181 | 181 |
182 scoped_ptr<XmlElement> stanza(sent_iq); | 182 scoped_ptr<XmlElement> stanza(sent_iq); |
183 ASSERT_TRUE(stanza != NULL); | 183 ASSERT_TRUE(stanza != nullptr); |
184 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 184 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
185 | 185 |
186 XmlElement* sent_iq2 = NULL; | 186 XmlElement* sent_iq2 = nullptr; |
187 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 187 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
188 .WillRepeatedly(Return(kTestJid)); | 188 .WillRepeatedly(Return(kTestJid)); |
189 EXPECT_CALL(signal_strategy_, GetNextId()) | 189 EXPECT_CALL(signal_strategy_, GetNextId()) |
190 .WillOnce(Return(kStanzaId + 1)); | 190 .WillOnce(Return(kStanzaId + 1)); |
191 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 191 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
192 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); | 192 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); |
193 | 193 |
194 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); | 194 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
195 response->AddAttr(QName(std::string(), "type"), "result"); | 195 response->AddAttr(QName(std::string(), "type"), "result"); |
196 XmlElement* result = | 196 XmlElement* result = |
197 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); | 197 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); |
198 response->AddElement(result); | 198 response->AddElement(result); |
199 XmlElement* expected_sequence_id = new XmlElement( | 199 XmlElement* expected_sequence_id = new XmlElement( |
200 QName(kChromotingXmlNamespace, "expected-sequence-id")); | 200 QName(kChromotingXmlNamespace, "expected-sequence-id")); |
201 result->AddElement(expected_sequence_id); | 201 result->AddElement(expected_sequence_id); |
202 const int kExpectedSequenceId = 456; | 202 const int kExpectedSequenceId = 456; |
203 expected_sequence_id->AddText(base::IntToString(kExpectedSequenceId)); | 203 expected_sequence_id->AddText(base::IntToString(kExpectedSequenceId)); |
204 heartbeat_sender_->ProcessResponse(false, NULL, response.get()); | 204 heartbeat_sender_->ProcessResponse(false, nullptr, response.get()); |
205 base::RunLoop().RunUntilIdle(); | 205 base::RunLoop().RunUntilIdle(); |
206 | 206 |
207 scoped_ptr<XmlElement> stanza2(sent_iq2); | 207 scoped_ptr<XmlElement> stanza2(sent_iq2); |
208 ASSERT_TRUE(stanza2 != NULL); | 208 ASSERT_TRUE(stanza2 != nullptr); |
209 ValidateHeartbeatStanza(stanza2.get(), | 209 ValidateHeartbeatStanza(stanza2.get(), |
210 base::IntToString(kExpectedSequenceId).c_str(), | 210 base::IntToString(kExpectedSequenceId).c_str(), |
211 nullptr); | 211 nullptr); |
212 | 212 |
213 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 213 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
214 base::RunLoop().RunUntilIdle(); | 214 base::RunLoop().RunUntilIdle(); |
215 } | 215 } |
216 | 216 |
217 void HeartbeatSenderTest::ProcessResponseWithInterval( | 217 void HeartbeatSenderTest::ProcessResponseWithInterval( |
218 bool is_offline_heartbeat_response, | 218 bool is_offline_heartbeat_response, |
219 int interval) { | 219 int interval) { |
220 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); | 220 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
221 response->AddAttr(QName(std::string(), "type"), "result"); | 221 response->AddAttr(QName(std::string(), "type"), "result"); |
222 | 222 |
223 XmlElement* result = new XmlElement( | 223 XmlElement* result = new XmlElement( |
224 QName(kChromotingXmlNamespace, "heartbeat-result")); | 224 QName(kChromotingXmlNamespace, "heartbeat-result")); |
225 response->AddElement(result); | 225 response->AddElement(result); |
226 | 226 |
227 XmlElement* set_interval = new XmlElement( | 227 XmlElement* set_interval = new XmlElement( |
228 QName(kChromotingXmlNamespace, "set-interval")); | 228 QName(kChromotingXmlNamespace, "set-interval")); |
229 result->AddElement(set_interval); | 229 result->AddElement(set_interval); |
230 | 230 |
231 set_interval->AddText(base::IntToString(interval)); | 231 set_interval->AddText(base::IntToString(interval)); |
232 | 232 |
233 heartbeat_sender_->ProcessResponse( | 233 heartbeat_sender_->ProcessResponse( |
234 is_offline_heartbeat_response, NULL, response.get()); | 234 is_offline_heartbeat_response, nullptr, response.get()); |
235 } | 235 } |
236 | 236 |
237 // Verify that ProcessResponse parses set-interval result. | 237 // Verify that ProcessResponse parses set-interval result. |
238 TEST_F(HeartbeatSenderTest, ProcessResponseSetInterval) { | 238 TEST_F(HeartbeatSenderTest, ProcessResponseSetInterval) { |
239 EXPECT_CALL(mock_heartbeat_successful_callback_, Run()); | 239 EXPECT_CALL(mock_heartbeat_successful_callback_, Run()); |
240 | 240 |
241 ProcessResponseWithInterval(false, kTestInterval); | 241 ProcessResponseWithInterval(false, kTestInterval); |
242 | 242 |
243 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); | 243 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); |
244 } | 244 } |
245 | 245 |
246 // Make sure SetHostOfflineReason sends a correct stanza. | 246 // Make sure SetHostOfflineReason sends a correct stanza. |
247 TEST_F(HeartbeatSenderTest, DoSetHostOfflineReason) { | 247 TEST_F(HeartbeatSenderTest, DoSetHostOfflineReason) { |
248 XmlElement* sent_iq = NULL; | 248 XmlElement* sent_iq = nullptr; |
249 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 249 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
250 .WillRepeatedly(Return(kTestJid)); | 250 .WillRepeatedly(Return(kTestJid)); |
251 EXPECT_CALL(signal_strategy_, GetNextId()) | 251 EXPECT_CALL(signal_strategy_, GetNextId()) |
252 .WillOnce(Return(kStanzaId)); | 252 .WillOnce(Return(kStanzaId)); |
253 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 253 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
254 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 254 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
255 EXPECT_CALL(signal_strategy_, GetState()) | 255 EXPECT_CALL(signal_strategy_, GetState()) |
256 .WillOnce(Return(SignalStrategy::DISCONNECTED)) | 256 .WillOnce(Return(SignalStrategy::DISCONNECTED)) |
257 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 257 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
258 | 258 |
259 heartbeat_sender_->SetHostOfflineReason( | 259 heartbeat_sender_->SetHostOfflineReason( |
260 "test_error", | 260 "test_error", |
261 base::Bind(base::DoNothing)); | 261 base::Bind(base::DoNothing)); |
262 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 262 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
263 base::RunLoop().RunUntilIdle(); | 263 base::RunLoop().RunUntilIdle(); |
264 | 264 |
265 scoped_ptr<XmlElement> stanza(sent_iq); | 265 scoped_ptr<XmlElement> stanza(sent_iq); |
266 ASSERT_TRUE(stanza != NULL); | 266 ASSERT_TRUE(stanza != nullptr); |
267 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); | 267 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); |
268 | 268 |
269 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 269 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
270 base::RunLoop().RunUntilIdle(); | 270 base::RunLoop().RunUntilIdle(); |
271 } | 271 } |
272 | 272 |
273 // Make sure SetHostOfflineReason triggers a callback when bot responds. | 273 // Make sure SetHostOfflineReason triggers a callback when bot responds. |
274 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { | 274 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { |
275 MockClosure mock_ack_callback; | 275 MockClosure mock_ack_callback; |
276 | 276 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
320 // Validate a heartbeat stanza. | 320 // Validate a heartbeat stanza. |
321 void HeartbeatSenderTest::ValidateHeartbeatStanza( | 321 void HeartbeatSenderTest::ValidateHeartbeatStanza( |
322 XmlElement* stanza, | 322 XmlElement* stanza, |
323 const char* expected_sequence_id, | 323 const char* expected_sequence_id, |
324 const char* expected_host_offline_reason) { | 324 const char* expected_host_offline_reason) { |
325 EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "to")), | 325 EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "to")), |
326 std::string(kTestBotJid)); | 326 std::string(kTestBotJid)); |
327 EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "type")), "set"); | 327 EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "type")), "set"); |
328 XmlElement* heartbeat_stanza = | 328 XmlElement* heartbeat_stanza = |
329 stanza->FirstNamed(QName(kChromotingXmlNamespace, "heartbeat")); | 329 stanza->FirstNamed(QName(kChromotingXmlNamespace, "heartbeat")); |
330 ASSERT_TRUE(heartbeat_stanza != NULL); | 330 ASSERT_TRUE(heartbeat_stanza != nullptr); |
331 EXPECT_EQ(expected_sequence_id, heartbeat_stanza->Attr( | 331 EXPECT_EQ(expected_sequence_id, heartbeat_stanza->Attr( |
332 buzz::QName(kChromotingXmlNamespace, "sequence-id"))); | 332 buzz::QName(kChromotingXmlNamespace, "sequence-id"))); |
333 if (expected_host_offline_reason == nullptr) { | 333 if (expected_host_offline_reason == nullptr) { |
334 EXPECT_FALSE(heartbeat_stanza->HasAttr( | 334 EXPECT_FALSE(heartbeat_stanza->HasAttr( |
335 buzz::QName(kChromotingXmlNamespace, "host-offline-reason"))); | 335 buzz::QName(kChromotingXmlNamespace, "host-offline-reason"))); |
336 } else { | 336 } else { |
337 EXPECT_EQ(expected_host_offline_reason, heartbeat_stanza->Attr( | 337 EXPECT_EQ(expected_host_offline_reason, heartbeat_stanza->Attr( |
338 buzz::QName(kChromotingXmlNamespace, "host-offline-reason"))); | 338 buzz::QName(kChromotingXmlNamespace, "host-offline-reason"))); |
339 } | 339 } |
340 EXPECT_EQ(std::string(kHostId), | 340 EXPECT_EQ(std::string(kHostId), |
341 heartbeat_stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); | 341 heartbeat_stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); |
342 | 342 |
343 QName signature_tag(kChromotingXmlNamespace, "signature"); | 343 QName signature_tag(kChromotingXmlNamespace, "signature"); |
344 XmlElement* signature = heartbeat_stanza->FirstNamed(signature_tag); | 344 XmlElement* signature = heartbeat_stanza->FirstNamed(signature_tag); |
345 ASSERT_TRUE(signature != NULL); | 345 ASSERT_TRUE(signature != nullptr); |
346 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == NULL); | 346 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr); |
347 | 347 |
348 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); | 348 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); |
349 ASSERT_TRUE(key_pair.get()); | 349 ASSERT_TRUE(key_pair.get()); |
350 std::string expected_signature = | 350 std::string expected_signature = |
351 key_pair->SignMessage(std::string(kTestJid) + ' ' + expected_sequence_id); | 351 key_pair->SignMessage(std::string(kTestJid) + ' ' + expected_sequence_id); |
352 EXPECT_EQ(expected_signature, signature->BodyText()); | 352 EXPECT_EQ(expected_signature, signature->BodyText()); |
353 } | 353 } |
354 | 354 |
355 } // namespace remoting | 355 } // namespace remoting |
OLD | NEW |