JD2022-TU1/main/extern/Hue/libhuestream/test/TestStream.cpp

/*******************************************************************************
 Copyright (c) 2013-2015 Koninklijke Philips N.V.
 All Rights Reserved.
 ********************************************************************************/

#include <huestream/stream/Stream.h>
#include "gtest/gtest.h"
#include "gmock/gmock.h"

#include <huestream/config/HueConfig.h>
#include <huestream/common/time/TimeManager.h>
#include "MockStreamClient.h"
#include "MockStreamStarter.h"
#include "MockStreamFactory.h"

using ::testing::AnyNumber;
using ::testing::_;
using ::testing::Expectation;
using ::testing::Invoke;
using ::testing::Return;

namespace huestream {

class TestStream: public testing::Test {
 public:
  std::shared_ptr<Stream> _stream;
  std::shared_ptr<MockStreamFactory> _mockStreamFactoryPtr;
  std::shared_ptr<MockStreamStarter> _mockStreamStarterPtr;
  std::shared_ptr<MockStreamClient> _mockStreamClientPtr;
  std::shared_ptr<TimeManager> _timeManager;
  std::shared_ptr<Bridge> _bridge;

  virtual void SetUp() {

    HueConfigPtr config = HueConfig::GetInstance();

    auto settings = std::make_shared<HueSettings>();
    settings->SetStreamingFilter(FILTER_LINEAR);
    settings->SetStreamingColorSpace(COLORSPACE_RGB);
    settings->SetUpdateFrequency(200);
    config->SetHueSettings(settings);

    config->SetAppSettings(std::make_shared<AppSettings>());
    config->GetAppSettings()->SetUseForcedActivation(true);

    _bridge = CreateBridge();

    _timeManager = std::make_shared<TimeManager>();
    config->SetTimeManager(_timeManager);
    config->SetEngine(std::make_shared<Engine>());

    _mockStreamFactoryPtr = std::make_shared<MockStreamFactory>();
    _mockStreamStarterPtr = std::make_shared<MockStreamStarter>();
    EXPECT_CALL(*_mockStreamFactoryPtr, CreateStreamStarter(_)).WillRepeatedly(Return(_mockStreamStarterPtr));

    _mockStreamClientPtr = std::make_shared<MockStreamClient>();
    _stream = std::make_shared<Stream>(_mockStreamFactoryPtr, _mockStreamClientPtr);
  }

  BridgePtr CreateBridge()
  {
    auto group1 = std::make_shared<Group>();
    group1->SetId(1);
    auto group2 = std::make_shared<Group>();
    group2->SetId(2);
    auto groupList = std::make_shared<GroupList>();
    groupList->push_back(group1);
    groupList->push_back(group2);
    auto bridge = std::make_shared<Bridge>();
    bridge->SetGroups(groupList);
    bridge->SetSelectedGroup(1);
    bridge->SetIpAddress("SOMEIP");
    bridge->SetUser("SOMEUSER");
    bridge->SetIsValidIp(true);
    bridge->SetIsAuthorized(true);
    bridge->SetId("SOMEID");
    bridge->SetModelId("BSB002");
    bridge->SetApiversion("1.18.0");
    bridge->SetSoftwareVersion("01037200");
    bridge->SetClientKey("DD129216F1A50E5D1C0CB356325745F2");
    return bridge;
  }

  void start_correctly_without_renderthread() {
    Expectation start = EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).WillOnce(Return(true));
    Expectation connect = EXPECT_CALL(*_mockStreamClientPtr, Connect(MatchBridgeIpAddress("SOMEIP"), 1337, _)).Times(1).After(start).WillOnce(Return(true));
    EXPECT_CALL(*_mockStreamClientPtr, Send(_)).Times(0);

    ASSERT_TRUE(_stream->Start(_bridge));
    ASSERT_TRUE(_stream->IsStreaming());
  }

  void stop_correctly() {
    EXPECT_CALL(*_mockStreamClientPtr, Disconnect()).Times(1);
    EXPECT_CALL(*_mockStreamStarterPtr, Stop()).Times(1);
    _stream->Stop();
  }

  void expect_no_actions() {
    EXPECT_CALL(*_mockStreamStarterPtr, Start(_)).Times(0);
    EXPECT_CALL(*_mockStreamStarterPtr, Stop()).Times(0);
    EXPECT_CALL(*_mockStreamClientPtr, Connect(_, _, _)).Times(0);
    EXPECT_CALL(*_mockStreamClientPtr, Send(_)).Times(0);
    EXPECT_CALL(*_mockStreamClientPtr, Disconnect()).Times(0);
  }

  virtual void TearDown() {
  }
};

TEST_F(TestStream, StartWithRenderThread) {
  Expectation start = EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).WillOnce(Return(true));
  Expectation connect = EXPECT_CALL(*_mockStreamClientPtr, Connect(MatchBridgeIpAddress("SOMEIP"), 1337, _)).Times(1).After(start).WillOnce(Return(true));
  Expectation sendFirst = EXPECT_CALL(*_mockStreamClientPtr, Send(MatchStreamSendSequence(0))).Times(1).After(start,
                                                                                                              connect).RetiresOnSaturation();
  Expectation sendSecond = EXPECT_CALL(*_mockStreamClientPtr, Send(MatchStreamSendSequence(1))).Times(1).After(start,
                                                                                                               connect,
                                                                                                               sendFirst).RetiresOnSaturation();
  EXPECT_CALL(*_mockStreamClientPtr, Send(_)).Times(AnyNumber()).After(start, connect, sendFirst, sendSecond);

  ASSERT_TRUE(_stream->StartWithRenderThread(_bridge));
  _timeManager->Sleep(100);

  ASSERT_TRUE(_stream->IsStreaming());

  stop_correctly();
}

TEST_F(TestStream, StartWithoutRenderThread) {
  start_correctly_without_renderthread();
  _timeManager->Sleep(100);

  EXPECT_CALL(*_mockStreamClientPtr, Send(MatchStreamSendSequence(0))).Times(1);
  _stream->RenderSingleFrame();
  EXPECT_CALL(*_mockStreamClientPtr, Send(MatchStreamSendSequence(1))).Times(1);
  _stream->RenderSingleFrame();

  stop_correctly();
}

TEST_F(TestStream, FailConnect) {
  Expectation start = EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).WillOnce(Return(true));
  Expectation connect = EXPECT_CALL(*_mockStreamClientPtr, Connect(MatchBridgeIpAddress("SOMEIP"), 1337, _)).Times(1).After(start).WillOnce(Return(false));
  EXPECT_CALL(*_mockStreamStarterPtr, Stop()).Times(1).After(connect);
  EXPECT_CALL(*_mockStreamClientPtr, Send(_)).Times(0);

  ASSERT_FALSE(_stream->Start(_bridge));
  ASSERT_FALSE(_stream->IsStreaming());
  _stream->RenderSingleFrame();

  expect_no_actions();
  _stream->Stop();
}

TEST_F(TestStream, FailCantActivate) {
  EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).WillOnce(Return(false));
  EXPECT_CALL(*_mockStreamClientPtr, Connect(_, _, _)).Times(0);
  EXPECT_CALL(*_mockStreamClientPtr, Send(_)).Times(0);

  ASSERT_FALSE(_stream->Start(_bridge));
  ASSERT_FALSE(_stream->IsStreaming());
  _stream->RenderSingleFrame();

  expect_no_actions();
  _stream->Stop();
}

TEST_F(TestStream, FailInvalidBridge) {
  expect_no_actions();

  ASSERT_FALSE(_stream->Start(make_shared<Bridge>()));
  ASSERT_FALSE(_stream->IsStreaming());
  _stream->RenderSingleFrame();

  expect_no_actions();
  _stream->Stop();
}

TEST_F(TestStream, StartOnSameBridgeAndGroupAsRunningDoesNothing) {
  start_correctly_without_renderthread();

  expect_no_actions();
  ASSERT_TRUE(_stream->Start(_bridge));

  stop_correctly();
}

TEST_F(TestStream, StartWhenAlreadyRunningOnDifferentBridgeFirstStops) {
  start_correctly_without_renderthread();

  _bridge->SetId("SOMEOTHERID");
  _bridge->SetIpAddress("SOMEOTHERIP");

  Expectation disconnect = EXPECT_CALL(*_mockStreamClientPtr, Disconnect()).Times(1);
  Expectation stop = EXPECT_CALL(*_mockStreamStarterPtr, Stop()).Times(1);
  Expectation start = EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).After(disconnect, stop).WillOnce(Return(true));
  Expectation connect = EXPECT_CALL(*_mockStreamClientPtr, Connect(MatchBridgeIpAddress("SOMEOTHERIP"), 1337, _)).Times(1).After(start).WillOnce(Return(true));

  ASSERT_TRUE(_stream->Start(_bridge));
  ASSERT_TRUE(_stream->IsStreaming());

  stop_correctly();
}

TEST_F(TestStream, StartWhenAlreadyRunningOnDifferentGroupFirstStops) {
  start_correctly_without_renderthread();

  _bridge->SetSelectedGroup(2);

  Expectation disconnect = EXPECT_CALL(*_mockStreamClientPtr, Disconnect()).Times(1);
  Expectation stop = EXPECT_CALL(*_mockStreamStarterPtr, Stop()).Times(1);
  Expectation start = EXPECT_CALL(*_mockStreamStarterPtr, Start(true)).Times(1).After(disconnect, stop).WillOnce(Return(true));
  Expectation connect = EXPECT_CALL(*_mockStreamClientPtr, Connect(MatchBridgeIpAddress("SOMEIP"), 1337, _)).Times(1).After(start).WillOnce(Return(true));

  ASSERT_TRUE(_stream->Start(_bridge));
  ASSERT_TRUE(_stream->IsStreaming());

  stop_correctly();
}

TEST_F(TestStream, StopWhenNotRunningDoesNothing) {
  expect_no_actions();
  _stream->Stop();
}


}