| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/time/time.h" |
| #include "components/copresence/copresence_state_impl.h" |
| #include "components/copresence/proto/data.pb.h" |
| #include "components/copresence/public/copresence_observer.h" |
| #include "components/copresence/tokens.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| using testing::ElementsAre; |
| using testing::Key; |
| using testing::SizeIs; |
| using testing::UnorderedElementsAre; |
| |
| // TODO(ckehoe): Test start and end time tracking. |
| |
| namespace google { |
| namespace protobuf { |
| |
| bool operator==(const MessageLite& A, const MessageLite& B) { |
| std::string serializedA; |
| CHECK(A.SerializeToString(&serializedA)); |
| |
| std::string serializedB; |
| CHECK(B.SerializeToString(&serializedB)); |
| |
| return serializedA == serializedB; |
| } |
| |
| } // namespace protobuf |
| } // namespace google |
| |
| namespace copresence { |
| |
| namespace { |
| |
| const base::Time kStartTime = base::Time::FromDoubleT(10); |
| const base::Time kStopTime = base::Time::FromDoubleT(20); |
| |
| Directive CreateDirective(const std::string& token, bool transmit) { |
| Directive directive; |
| TokenInstruction* instruction = directive.mutable_token_instruction(); |
| instruction->set_token_id(token); |
| instruction->set_medium(AUDIO_ULTRASOUND_PASSBAND); |
| if (transmit) |
| instruction->set_token_instruction_type(TRANSMIT); |
| return directive; |
| } |
| |
| template<typename TokenType> |
| TokenType CreateToken(const std::string& id) { |
| TokenType token; |
| token.id = id; |
| token.medium = AUDIO_ULTRASOUND_PASSBAND; |
| token.start_time = kStartTime; |
| return token; |
| } |
| |
| } // namespace |
| |
| class CopresenceStateTest : public CopresenceObserver, |
| public testing::Test { |
| public: |
| CopresenceStateTest() : directive_notifications_(0) { |
| state_.AddObserver(this); |
| } |
| |
| protected: |
| CopresenceStateImpl state_; |
| |
| int directive_notifications_; |
| std::vector<std::string> transmitted_updates_; |
| std::vector<std::string> received_updates_; |
| |
| private: |
| // CopresenceObserver implementation. |
| void DirectivesUpdated() override { |
| directive_notifications_++; |
| } |
| void TokenTransmitted(const TransmittedToken& token) override { |
| transmitted_updates_.push_back(token.id); |
| } |
| void TokenReceived(const ReceivedToken& token) override { |
| received_updates_.push_back(token.id); |
| } |
| }; |
| |
| TEST_F(CopresenceStateTest, Directives) { |
| std::vector<Directive> directives; |
| directives.push_back(CreateDirective("transmit 1", true)); |
| directives.push_back(CreateDirective("transmit 2", true)); |
| directives.push_back(CreateDirective("receive", false)); |
| state_.UpdateDirectives(directives); |
| |
| EXPECT_EQ(1, directive_notifications_); |
| EXPECT_EQ(directives, state_.active_directives()); |
| EXPECT_THAT(transmitted_updates_, ElementsAre("transmit 1", "transmit 2")); |
| EXPECT_THAT(state_.transmitted_tokens(), |
| UnorderedElementsAre(Key("transmit 1"), Key("transmit 2"))); |
| |
| directives.clear(); |
| directives.push_back(CreateDirective("transmit 1", true)); |
| state_.UpdateDirectives(directives); |
| EXPECT_EQ(2, directive_notifications_); |
| EXPECT_EQ(directives, state_.active_directives()); |
| EXPECT_THAT(state_.transmitted_tokens(), SizeIs(2)); |
| } |
| |
| TEST_F(CopresenceStateTest, TransmittedTokens) { |
| state_.UpdateTransmittedToken(CreateToken<TransmittedToken>("A")); |
| state_.UpdateTransmittedToken(CreateToken<TransmittedToken>("B")); |
| |
| EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B")); |
| EXPECT_THAT(state_.transmitted_tokens(), |
| UnorderedElementsAre(Key("A"), Key("B"))); |
| |
| TransmittedToken tokenA = CreateToken<TransmittedToken>("A"); |
| tokenA.stop_time = kStopTime; |
| state_.UpdateTransmittedToken(tokenA); |
| |
| EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B", "A")); |
| EXPECT_EQ(kStopTime, state_.transmitted_tokens().find("A")->second.stop_time); |
| |
| state_.UpdateReceivedToken(CreateToken<ReceivedToken>("B")); |
| EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B", "A", "B")); |
| EXPECT_TRUE(state_.transmitted_tokens().find("B") |
| ->second.broadcast_confirmed); |
| } |
| |
| TEST_F(CopresenceStateTest, ReceivedTokens) { |
| state_.UpdateReceivedToken(CreateToken<ReceivedToken>("A")); |
| state_.UpdateReceivedToken(CreateToken<ReceivedToken>("B")); |
| |
| EXPECT_THAT(received_updates_, ElementsAre("A", "B")); |
| EXPECT_THAT(state_.received_tokens(), |
| UnorderedElementsAre(Key("A"), Key("B"))); |
| |
| state_.UpdateTokenStatus("A", copresence::VALID); |
| EXPECT_THAT(received_updates_, ElementsAre("A", "B", "A")); |
| EXPECT_EQ(ReceivedToken::VALID, |
| state_.received_tokens().find("A")->second.valid); |
| } |
| |
| } // namespace copresence |