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 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 list->insert(arg0); | 50 list->insert(arg0); |
51 } | 51 } |
52 ACTION_P(RemoveListener, list) { | 52 ACTION_P(RemoveListener, list) { |
53 EXPECT_TRUE(list->find(arg0) != list->end()); | 53 EXPECT_TRUE(list->find(arg0) != list->end()); |
54 list->erase(arg0); | 54 list->erase(arg0); |
55 } | 55 } |
56 | 56 |
57 class HeartbeatSenderTest | 57 class HeartbeatSenderTest |
58 : public testing::Test { | 58 : public testing::Test { |
59 protected: | 59 protected: |
| 60 HeartbeatSenderTest() : signal_strategy_(SignalingAddress(kTestJid)) {} |
| 61 |
60 void SetUp() override { | 62 void SetUp() override { |
61 key_pair_ = RsaKeyPair::FromString(kTestRsaKeyPair); | 63 key_pair_ = RsaKeyPair::FromString(kTestRsaKeyPair); |
62 ASSERT_TRUE(key_pair_.get()); | 64 ASSERT_TRUE(key_pair_.get()); |
63 EXPECT_CALL(signal_strategy_, GetState()) | 65 EXPECT_CALL(signal_strategy_, GetState()) |
64 .WillOnce(Return(SignalStrategy::DISCONNECTED)); | 66 .WillOnce(Return(SignalStrategy::DISCONNECTED)); |
65 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) | 67 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) |
66 .WillRepeatedly(AddListener(&signal_strategy_listeners_)); | 68 .WillRepeatedly(AddListener(&signal_strategy_listeners_)); |
67 EXPECT_CALL(signal_strategy_, RemoveListener(NotNull())) | 69 EXPECT_CALL(signal_strategy_, RemoveListener(NotNull())) |
68 .WillRepeatedly(RemoveListener(&signal_strategy_listeners_)); | 70 .WillRepeatedly(RemoveListener(&signal_strategy_listeners_)); |
69 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
70 .WillRepeatedly(Return(kTestJid)); | |
71 EXPECT_CALL(mock_unknown_host_id_error_callback_, Run()) | 71 EXPECT_CALL(mock_unknown_host_id_error_callback_, Run()) |
72 .Times(0); | 72 .Times(0); |
73 | 73 |
74 heartbeat_sender_.reset( | 74 heartbeat_sender_.reset( |
75 new HeartbeatSender(mock_heartbeat_successful_callback_.Get(), | 75 new HeartbeatSender(mock_heartbeat_successful_callback_.Get(), |
76 mock_unknown_host_id_error_callback_.Get(), kHostId, | 76 mock_unknown_host_id_error_callback_.Get(), kHostId, |
77 &signal_strategy_, key_pair_, kTestBotJid)); | 77 &signal_strategy_, key_pair_, kTestBotJid)); |
78 } | 78 } |
79 | 79 |
80 void TearDown() override { | 80 void TearDown() override { |
(...skipping 14 matching lines...) Expand all Loading... |
95 base::MockCallback<base::Closure> mock_heartbeat_successful_callback_; | 95 base::MockCallback<base::Closure> mock_heartbeat_successful_callback_; |
96 base::MockCallback<base::Closure> mock_unknown_host_id_error_callback_; | 96 base::MockCallback<base::Closure> 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 std::unique_ptr<HeartbeatSender> heartbeat_sender_; | 99 std::unique_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 = nullptr; | 104 XmlElement* sent_iq = nullptr; |
105 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
106 .WillRepeatedly(Return(kTestJid)); | |
107 EXPECT_CALL(signal_strategy_, GetNextId()) | 105 EXPECT_CALL(signal_strategy_, GetNextId()) |
108 .WillOnce(Return(kStanzaId)); | 106 .WillOnce(Return(kStanzaId)); |
109 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 107 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
110 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 108 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
111 EXPECT_CALL(signal_strategy_, GetState()) | 109 EXPECT_CALL(signal_strategy_, GetState()) |
112 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 110 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
113 | 111 |
114 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 112 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
115 base::RunLoop().RunUntilIdle(); | 113 base::RunLoop().RunUntilIdle(); |
116 | 114 |
117 std::unique_ptr<XmlElement> stanza(sent_iq); | 115 std::unique_ptr<XmlElement> stanza(sent_iq); |
118 ASSERT_TRUE(stanza != nullptr); | 116 ASSERT_TRUE(stanza != nullptr); |
119 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 117 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
120 | 118 |
121 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 119 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
122 base::RunLoop().RunUntilIdle(); | 120 base::RunLoop().RunUntilIdle(); |
123 } | 121 } |
124 | 122 |
125 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats | 123 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats |
126 // are sent, with the correct sequence IDs. | 124 // are sent, with the correct sequence IDs. |
127 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { | 125 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) { |
128 XmlElement* sent_iq = nullptr; | 126 XmlElement* sent_iq = nullptr; |
129 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
130 .WillRepeatedly(Return(kTestJid)); | |
131 EXPECT_CALL(signal_strategy_, GetNextId()) | 127 EXPECT_CALL(signal_strategy_, GetNextId()) |
132 .WillOnce(Return(kStanzaId)); | 128 .WillOnce(Return(kStanzaId)); |
133 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 129 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
134 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 130 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
135 EXPECT_CALL(signal_strategy_, GetState()) | 131 EXPECT_CALL(signal_strategy_, GetState()) |
136 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 132 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
137 | 133 |
138 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 134 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
139 base::RunLoop().RunUntilIdle(); | 135 base::RunLoop().RunUntilIdle(); |
140 | 136 |
141 std::unique_ptr<XmlElement> stanza(sent_iq); | 137 std::unique_ptr<XmlElement> stanza(sent_iq); |
142 ASSERT_TRUE(stanza != nullptr); | 138 ASSERT_TRUE(stanza != nullptr); |
143 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 139 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
144 | 140 |
145 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 141 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
146 base::RunLoop().RunUntilIdle(); | 142 base::RunLoop().RunUntilIdle(); |
147 | 143 |
148 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
149 .WillRepeatedly(Return(kTestJid)); | |
150 EXPECT_CALL(signal_strategy_, GetNextId()) | 144 EXPECT_CALL(signal_strategy_, GetNextId()) |
151 .WillOnce(Return(kStanzaId + 1)); | 145 .WillOnce(Return(kStanzaId + 1)); |
152 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 146 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
153 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 147 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
154 | 148 |
155 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 149 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
156 base::RunLoop().RunUntilIdle(); | 150 base::RunLoop().RunUntilIdle(); |
157 | 151 |
158 std::unique_ptr<XmlElement> stanza2(sent_iq); | 152 std::unique_ptr<XmlElement> stanza2(sent_iq); |
159 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); | 153 ValidateHeartbeatStanza(stanza2.get(), "1", nullptr); |
160 | 154 |
161 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 155 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
162 base::RunLoop().RunUntilIdle(); | 156 base::RunLoop().RunUntilIdle(); |
163 } | 157 } |
164 | 158 |
165 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent, | 159 // 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 | 160 // reply with an expected sequence ID, and make sure two valid heartbeats |
167 // are sent, with the correct sequence IDs. | 161 // are sent, with the correct sequence IDs. |
168 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { | 162 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) { |
169 XmlElement* sent_iq = nullptr; | 163 XmlElement* sent_iq = nullptr; |
170 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
171 .WillRepeatedly(Return(kTestJid)); | |
172 EXPECT_CALL(signal_strategy_, GetNextId()) | 164 EXPECT_CALL(signal_strategy_, GetNextId()) |
173 .WillOnce(Return(kStanzaId)); | 165 .WillOnce(Return(kStanzaId)); |
174 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 166 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
175 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 167 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
176 EXPECT_CALL(signal_strategy_, GetState()) | 168 EXPECT_CALL(signal_strategy_, GetState()) |
177 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 169 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
178 | 170 |
179 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 171 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
180 base::RunLoop().RunUntilIdle(); | 172 base::RunLoop().RunUntilIdle(); |
181 | 173 |
182 std::unique_ptr<XmlElement> stanza(sent_iq); | 174 std::unique_ptr<XmlElement> stanza(sent_iq); |
183 ASSERT_TRUE(stanza != nullptr); | 175 ASSERT_TRUE(stanza != nullptr); |
184 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); | 176 ValidateHeartbeatStanza(stanza.get(), "0", nullptr); |
185 | 177 |
186 XmlElement* sent_iq2 = nullptr; | 178 XmlElement* sent_iq2 = nullptr; |
187 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
188 .WillRepeatedly(Return(kTestJid)); | |
189 EXPECT_CALL(signal_strategy_, GetNextId()) | 179 EXPECT_CALL(signal_strategy_, GetNextId()) |
190 .WillOnce(Return(kStanzaId + 1)); | 180 .WillOnce(Return(kStanzaId + 1)); |
191 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 181 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
192 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); | 182 .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true))); |
193 | 183 |
194 std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); | 184 std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
195 response->AddAttr(QName(std::string(), "type"), "result"); | 185 response->AddAttr(QName(std::string(), "type"), "result"); |
196 XmlElement* result = | 186 XmlElement* result = |
197 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); | 187 new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result")); |
198 response->AddElement(result); | 188 response->AddElement(result); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
241 ProcessResponseWithInterval(false, kTestInterval); | 231 ProcessResponseWithInterval(false, kTestInterval); |
242 | 232 |
243 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); | 233 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); |
244 } | 234 } |
245 | 235 |
246 // Make sure SetHostOfflineReason sends a correct stanza. | 236 // Make sure SetHostOfflineReason sends a correct stanza. |
247 TEST_F(HeartbeatSenderTest, DoSetHostOfflineReason) { | 237 TEST_F(HeartbeatSenderTest, DoSetHostOfflineReason) { |
248 XmlElement* sent_iq = nullptr; | 238 XmlElement* sent_iq = nullptr; |
249 base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback; | 239 base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback; |
250 | 240 |
251 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
252 .WillRepeatedly(Return(kTestJid)); | |
253 EXPECT_CALL(signal_strategy_, GetNextId()) | 241 EXPECT_CALL(signal_strategy_, GetNextId()) |
254 .WillOnce(Return(kStanzaId)); | 242 .WillOnce(Return(kStanzaId)); |
255 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 243 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
256 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 244 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
257 EXPECT_CALL(signal_strategy_, GetState()) | 245 EXPECT_CALL(signal_strategy_, GetState()) |
258 .WillOnce(Return(SignalStrategy::DISCONNECTED)) | 246 .WillOnce(Return(SignalStrategy::DISCONNECTED)) |
259 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 247 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
260 EXPECT_CALL(mock_ack_callback, Run(_)).Times(0); | 248 EXPECT_CALL(mock_ack_callback, Run(_)).Times(0); |
261 | 249 |
262 heartbeat_sender_->SetHostOfflineReason("test_error", kTestTimeout, | 250 heartbeat_sender_->SetHostOfflineReason("test_error", kTestTimeout, |
263 mock_ack_callback.Get()); | 251 mock_ack_callback.Get()); |
264 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 252 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
265 base::RunLoop().RunUntilIdle(); | 253 base::RunLoop().RunUntilIdle(); |
266 | 254 |
267 std::unique_ptr<XmlElement> stanza(sent_iq); | 255 std::unique_ptr<XmlElement> stanza(sent_iq); |
268 ASSERT_TRUE(stanza != nullptr); | 256 ASSERT_TRUE(stanza != nullptr); |
269 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); | 257 ValidateHeartbeatStanza(stanza.get(), "0", "test_error"); |
270 | 258 |
271 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 259 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
272 base::RunLoop().RunUntilIdle(); | 260 base::RunLoop().RunUntilIdle(); |
273 } | 261 } |
274 | 262 |
275 // Make sure SetHostOfflineReason triggers a callback when bot responds. | 263 // Make sure SetHostOfflineReason triggers a callback when bot responds. |
276 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { | 264 TEST_F(HeartbeatSenderTest, ProcessHostOfflineResponses) { |
277 base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback; | 265 base::MockCallback<base::Callback<void(bool success)>> mock_ack_callback; |
278 | 266 |
279 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
280 .WillRepeatedly(Return(kTestJid)); | |
281 EXPECT_CALL(signal_strategy_, GetNextId()) | 267 EXPECT_CALL(signal_strategy_, GetNextId()) |
282 .WillOnce(Return(kStanzaId)); | 268 .WillOnce(Return(kStanzaId)); |
283 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 269 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
284 .WillOnce(DoAll(DeleteArg<0>(), Return(true))); | 270 .WillOnce(DoAll(DeleteArg<0>(), Return(true))); |
285 EXPECT_CALL(signal_strategy_, GetState()) | 271 EXPECT_CALL(signal_strategy_, GetState()) |
286 .WillOnce(Return(SignalStrategy::DISCONNECTED)) | 272 .WillOnce(Return(SignalStrategy::DISCONNECTED)) |
287 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 273 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
288 EXPECT_CALL(mock_heartbeat_successful_callback_, Run()) | 274 EXPECT_CALL(mock_heartbeat_successful_callback_, Run()) |
289 .WillRepeatedly(Return()); | 275 .WillRepeatedly(Return()); |
290 | 276 |
(...skipping 23 matching lines...) Expand all Loading... |
314 ProcessResponseWithInterval(true, kTestInterval); | 300 ProcessResponseWithInterval(true, kTestInterval); |
315 base::RunLoop().RunUntilIdle(); | 301 base::RunLoop().RunUntilIdle(); |
316 | 302 |
317 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); | 303 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
318 base::RunLoop().RunUntilIdle(); | 304 base::RunLoop().RunUntilIdle(); |
319 } | 305 } |
320 | 306 |
321 // The first heartbeat should include host OS information. | 307 // The first heartbeat should include host OS information. |
322 TEST_F(HeartbeatSenderTest, HostOsInfo) { | 308 TEST_F(HeartbeatSenderTest, HostOsInfo) { |
323 XmlElement* sent_iq = nullptr; | 309 XmlElement* sent_iq = nullptr; |
324 EXPECT_CALL(signal_strategy_, GetLocalJid()) | |
325 .WillRepeatedly(Return(kTestJid)); | |
326 EXPECT_CALL(signal_strategy_, GetNextId()) | 310 EXPECT_CALL(signal_strategy_, GetNextId()) |
327 .WillOnce(Return(kStanzaId)); | 311 .WillOnce(Return(kStanzaId)); |
328 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) | 312 EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull())) |
329 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 313 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
330 EXPECT_CALL(signal_strategy_, GetState()) | 314 EXPECT_CALL(signal_strategy_, GetState()) |
331 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); | 315 .WillRepeatedly(Return(SignalStrategy::CONNECTED)); |
332 | 316 |
333 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); | 317 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
334 base::RunLoop().RunUntilIdle(); | 318 base::RunLoop().RunUntilIdle(); |
335 | 319 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
382 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr); | 366 EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == nullptr); |
383 | 367 |
384 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); | 368 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair); |
385 ASSERT_TRUE(key_pair.get()); | 369 ASSERT_TRUE(key_pair.get()); |
386 std::string expected_signature = key_pair->SignMessage( | 370 std::string expected_signature = key_pair->SignMessage( |
387 std::string(kTestJidNormalized) + ' ' + expected_sequence_id); | 371 std::string(kTestJidNormalized) + ' ' + expected_sequence_id); |
388 EXPECT_EQ(expected_signature, signature->BodyText()); | 372 EXPECT_EQ(expected_signature, signature->BodyText()); |
389 } | 373 } |
390 | 374 |
391 } // namespace remoting | 375 } // namespace remoting |
OLD | NEW |