summaryrefslogtreecommitdiff
path: root/cpp/tests/polo/pairing/pairingsessiontest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/tests/polo/pairing/pairingsessiontest.cc')
-rw-r--r--cpp/tests/polo/pairing/pairingsessiontest.cc269
1 files changed, 269 insertions, 0 deletions
diff --git a/cpp/tests/polo/pairing/pairingsessiontest.cc b/cpp/tests/polo/pairing/pairingsessiontest.cc
new file mode 100644
index 0000000..4da67f0
--- /dev/null
+++ b/cpp/tests/polo/pairing/pairingsessiontest.cc
@@ -0,0 +1,269 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Tests for PairingSession.
+
+#include <gtest/gtest.h>
+#include <polo/pairing/clientpairingsession.h>
+#include "polo/pairing/mocks.h"
+#include "polo/wire/mocks.h"
+
+using ::testing::Const;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::StrictMock;
+using ::testing::_;
+
+namespace polo {
+namespace pairing {
+
+class TestPairingSession : public PairingSession {
+ public:
+ TestPairingSession(wire::PoloWireAdapter* wire,
+ PairingContext* context,
+ PoloChallengeResponse* challenge)
+ : PairingSession(wire, context, challenge) {
+ }
+
+ void TestDoPairingPhase() {
+ DoPairingPhase();
+ }
+
+ bool TestSetConfiguration(const message::ConfigurationMessage& message) {
+ return SetConfiguration(message);
+ }
+
+ const message::ConfigurationMessage* GetConfiguration() {
+ return configuration();
+ }
+
+ const message::OptionsMessage& GetLocalOptions() {
+ return local_options();
+ }
+
+ void TestOnSecretMessage(const message::SecretMessage& message) {
+ OnSecretMessage(message);
+ }
+
+ void TestOnSecretAckmessage(const message::SecretAckMessage& message) {
+ OnSecretAckMessage(message);
+ }
+
+ MOCK_METHOD0(DoInitializationPhase, void());
+ MOCK_METHOD0(DoConfigurationPhase, void());
+ MOCK_METHOD1(OnConfigurationMessage,
+ void(const pairing::message::ConfigurationMessage& message));
+ MOCK_METHOD1(OnConfigurationAckMessage,
+ void(const pairing::message::ConfigurationAckMessage& message));
+ MOCK_METHOD1(OnOptionsMessage,
+ void(const pairing::message::OptionsMessage& message));
+ MOCK_METHOD1(OnPairingRequestMessage,
+ void(const pairing::message::PairingRequestMessage& message));
+ MOCK_METHOD1(OnPairingRequestAckMessage,
+ void(const pairing::message::PairingRequestAckMessage& message));
+};
+
+class PairingSessionTest : public ::testing::Test {
+ protected:
+ PairingSessionTest()
+ : interface_(),
+ wire_(&interface_),
+ challenge_(),
+ context_(NULL, NULL, false),
+ session_(&wire_, &context_, &challenge_) {
+ }
+
+ virtual void SetUp() {
+ }
+
+ virtual void TearDown() {
+ }
+
+ void InitSession() {
+ InSequence sequence;
+
+ EXPECT_CALL(listener_, OnSessionCreated());
+ EXPECT_CALL(session_, DoInitializationPhase());
+
+ session_.DoPair(&listener_);
+ }
+
+ StrictMock<wire::MockWireInterface> interface_;
+ StrictMock<wire::MockWireAdapter> wire_;
+ StrictMock<MockChallengeResponse> challenge_;
+ PairingContext context_;
+ StrictMock<MockPairingListener> listener_;
+ StrictMock<TestPairingSession> session_;
+};
+
+TEST_F(PairingSessionTest, DoPair) {
+ // Test the base SetUp case which initializes the pairing session.
+ InitSession();
+}
+
+TEST_F(PairingSessionTest, SetConfiguration) {
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ message::ConfigurationMessage configuration(encoding,
+ message::OptionsMessage::kInputDevice);
+ session_.TestSetConfiguration(configuration);
+
+ ASSERT_TRUE(session_.GetConfiguration());
+ ASSERT_EQ(encoding::EncodingOption::kHexadecimal,
+ session_.GetConfiguration()->encoding().encoding_type());
+ ASSERT_EQ(8, session_.GetConfiguration()->encoding().symbol_length());
+ ASSERT_EQ(message::OptionsMessage::kInputDevice,
+ session_.GetConfiguration()->client_role());
+
+ ASSERT_TRUE(session_.encoder());
+ ASSERT_EQ(2, session_.encoder()->symbols_per_byte());
+}
+
+TEST_F(PairingSessionTest, DoPairingPhaseInputDevice) {
+ InitSession();
+ InSequence sequence;
+
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ message::ConfigurationMessage configuration(encoding,
+ message::OptionsMessage::kInputDevice);
+ session_.TestSetConfiguration(configuration);
+
+ EXPECT_CALL(listener_, OnPerformInputDeviceRole());
+
+ session_.TestDoPairingPhase();
+}
+
+TEST_F(PairingSessionTest, DoPairingPhaseDisplayDevice) {
+ InitSession();
+ InSequence sequence;
+
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ message::ConfigurationMessage configuration(encoding,
+ message::OptionsMessage::kDisplayDevice);
+ session_.TestSetConfiguration(configuration);
+
+ EXPECT_CALL(challenge_, GetGamma(_)).WillOnce(Return(new Gamma(10, 0x5)));
+ EXPECT_CALL(listener_, OnPerformOutputDeviceRole(Gamma(10, 0x5)));
+ EXPECT_CALL(wire_, GetNextMessage());
+
+ session_.TestDoPairingPhase();
+}
+
+TEST_F(PairingSessionTest, AddInputEncoding) {
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ session_.AddInputEncoding(encoding);
+ ASSERT_TRUE(session_.GetLocalOptions().SupportsInputEncoding(encoding));
+}
+
+TEST_F(PairingSessionTest, AddInputEncodingInvalidEncoding) {
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 1);
+ session_.AddInputEncoding(encoding);
+ ASSERT_FALSE(session_.GetLocalOptions().SupportsInputEncoding(encoding));
+}
+
+TEST_F(PairingSessionTest, AddOutputEncoding) {
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ session_.AddOutputEncoding(encoding);
+ ASSERT_TRUE(session_.GetLocalOptions().SupportsOutputEncoding(encoding));
+}
+
+TEST_F(PairingSessionTest, AddOutputEncodingInvalidEncoding) {
+ encoding::EncodingOption encoding(encoding::EncodingOption::kUnknown, 8);
+ session_.AddOutputEncoding(encoding);
+ ASSERT_FALSE(session_.GetLocalOptions().SupportsOutputEncoding(encoding));
+}
+
+TEST_F(PairingSessionTest, SetSecret) {
+ InitSession();
+ InSequence sequence;
+
+ // Do the setup so the session is expecting the secret.
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ message::ConfigurationMessage configuration(encoding,
+ message::OptionsMessage::kInputDevice);
+ session_.TestSetConfiguration(configuration);
+
+ EXPECT_CALL(listener_, OnPerformInputDeviceRole());
+
+ session_.TestDoPairingPhase();
+
+ Gamma gamma(5, 0x1);
+ Nonce nonce(5, 0x2);
+ Alpha alpha(5, 0x3);
+
+ EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true));
+ EXPECT_CALL(challenge_, ExtractNonce(gamma))
+ .WillOnce(Return(new Nonce(nonce)));
+ EXPECT_CALL(challenge_, GetAlpha(nonce))
+ .WillOnce(Return(new Alpha(alpha)));
+
+ EXPECT_CALL(wire_, SendSecretMessage(_));
+ EXPECT_CALL(wire_, GetNextMessage());
+
+ session_.SetSecret(gamma);
+}
+
+TEST_F(PairingSessionTest, OnSecretMessage) {
+ InitSession();
+ InSequence sequence;
+
+ // Do the setup to set the secret.
+ encoding::EncodingOption encoding(encoding::EncodingOption::kHexadecimal, 8);
+ message::ConfigurationMessage configuration(encoding,
+ message::OptionsMessage::kInputDevice);
+ session_.TestSetConfiguration(configuration);
+
+ EXPECT_CALL(listener_, OnPerformInputDeviceRole());
+
+ session_.TestDoPairingPhase();
+
+ Gamma gamma(5, 0x1);
+ Nonce nonce(5, 0x2);
+ Alpha alpha(5, 0x3);
+
+ EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true));
+ EXPECT_CALL(challenge_, ExtractNonce(gamma))
+ .WillOnce(Return(new Nonce(nonce)));
+ EXPECT_CALL(challenge_, GetAlpha(nonce))
+ .WillOnce(Return(new Alpha(alpha)));
+
+ EXPECT_CALL(wire_, SendSecretMessage(_));
+ EXPECT_CALL(wire_, GetNextMessage());
+
+ session_.SetSecret(gamma);
+
+ EXPECT_CALL(challenge_, GetAlpha(nonce))
+ .WillOnce(Return(new Alpha(alpha)));
+
+ EXPECT_CALL(challenge_, GetAlpha(nonce))
+ .WillOnce(Return(new Alpha(alpha)));
+
+ EXPECT_CALL(wire_, SendSecretAckMessage(_));
+ EXPECT_CALL(listener_, OnPairingSuccess());
+
+ message::SecretMessage message(alpha);
+ session_.TestOnSecretMessage(message);
+}
+
+TEST_F(PairingSessionTest, OnSecretAckMessage) {
+ EXPECT_CALL(listener_, OnPairingSuccess());
+
+ Alpha alpha(5, 0x3);
+ message::SecretAckMessage message(alpha);
+ session_.TestOnSecretAckmessage(message);
+}
+
+} // namespace pairing
+} // namespace polo
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-11 20:34:32 +0000