942 lines
43 KiB
C++
942 lines
43 KiB
C++
/*
|
|
* DirectiveSequencerTest.cpp
|
|
*
|
|
* Copyright 2017 Amazon.com, Inc. or its affiliates. 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.
|
|
* A copy of the License is located at
|
|
*
|
|
* http://aws.amazon.com/apache2.0/
|
|
*
|
|
* or in the "license" file accompanying this file. This file 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.
|
|
*/
|
|
|
|
#include <chrono>
|
|
#include <future>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <gtest/gtest.h>
|
|
#include <gmock/gmock.h>
|
|
|
|
#include "ADSL/DirectiveSequencer.h"
|
|
|
|
#include "ACL/AttachmentManagerInterface.h"
|
|
|
|
using namespace ::testing;
|
|
|
|
namespace alexaClientSDK {
|
|
namespace adsl {
|
|
namespace test {
|
|
|
|
using namespace avsCommon;
|
|
using namespace acl;
|
|
|
|
/// Macro to wait for a future using the default done timeout and assert that the timeout was not reached.
|
|
#define ASSERT_WAIT_FOR_TIMEOUT(future) ASSERT_EQ(future.wait_for(DEFAULT_DONE_TIMEOUT_MS), std::future_status::ready)
|
|
|
|
/// Default amount of time taken to handle a directive.
|
|
static const std::chrono::milliseconds DEFAULT_HANDLING_TIME_MS(0);
|
|
|
|
/// Long amount of time for handling a directive to allow other things to happen (we should not reach this).
|
|
static const std::chrono::milliseconds LONG_HANDLING_TIME_MS(30000);
|
|
|
|
/// Timeout used when waiting for tests to complete (we should not reach this).
|
|
static const std::chrono::milliseconds DEFAULT_DONE_TIMEOUT_MS(60000);
|
|
|
|
/// Namespace for Test only directives.
|
|
static const std::string NAMESPACE_TEST("Test");
|
|
|
|
/// Namespace for Speaker directives.
|
|
static const std::string NAMESPACE_SPEAKER("Speaker");
|
|
|
|
/// Namespace for SpeechSynthesizer directives.
|
|
static const std::string NAMESPACE_SPEECH_SYNTHESIZER("SpeechSynthesizer");
|
|
|
|
/// Namespace for AudioPlayer directives.
|
|
static const std::string NAMESPACE_AUDIO_PLAYER("AudioPlayer");
|
|
|
|
/// Name for Test directive used to terminate tests.
|
|
static const std::string NAME_DONE("Done");
|
|
|
|
/// Name for Speaker::setVolume Directives.
|
|
static const std::string NAME_SET_VOLUME("SetVolume");
|
|
|
|
/// Name for SpeechSynthesizer::Speak directives.
|
|
static const std::string NAME_SPEAK("Speak");
|
|
|
|
/// Name for AutioPlayer::Play directives.
|
|
static const std::string NAME_PLAY("Play");
|
|
|
|
/// Name for Test::Blocking directives
|
|
static const std::string NAME_BLOCKING("Blocking");
|
|
|
|
/// Name for Test::Non-Blocking directives.
|
|
static const std::string NAME_NON_BLOCKING("Non-Blocking");
|
|
|
|
/// MessageId for Testing:Done directives used to terminate tests.
|
|
static const std::string MESSAGE_ID_DONE("Message_Done");
|
|
|
|
/// Generic messageId used for tests.
|
|
static const std::string MESSAGE_ID_0("Message_0");
|
|
|
|
/// Generic MessageId used for test.
|
|
static const std::string MESSAGE_ID_1("Message_1");
|
|
|
|
/// Generic MessageId used for tests.
|
|
static const std::string MESSAGE_ID_2("Message_2");
|
|
|
|
/// Default DialogRequestId for directives used to terminate tests.
|
|
static const std::string DIALOG_REQUEST_ID_DONE("DialogRequestId_Done");
|
|
|
|
/// Generic DialogRequestId used for tests.
|
|
static const std::string DIALOG_REQUEST_ID_0("DialogRequestId_0");
|
|
|
|
/// Generic DialogRequestId used for tests.
|
|
static const std::string DIALOG_REQUEST_ID_1("DialogRequestId_1");
|
|
|
|
/// An unparsed directive for test.
|
|
static const std::string UNPARSED_DIRECTIVE("unparsedDirectiveForTest");
|
|
|
|
/// A paylaod for test;
|
|
static const std::string PAYLOAD_TEST("payloadForTest");
|
|
|
|
/// Generic DialogRequestId used for tests.
|
|
static const std::string DIALOG_REQUEST_ID_2("DialogRequestId_2");
|
|
|
|
/**
|
|
* MockDirectiveHandler used to verify DirectiveSequencer behavior.
|
|
* NOTE: Each instance contains directive specific state, so it must only be be used to process a single directive.
|
|
*/
|
|
class MockDirectiveHandler : public DirectiveHandlerInterface {
|
|
public:
|
|
|
|
/**
|
|
* Create a MockDirectiveHandler.
|
|
* @param handlingTimeMs The amount of time (in milliseconds) this handler takes to handle directives.
|
|
* @return A new MockDirectiveHandler.
|
|
*/
|
|
static std::shared_ptr<NiceMock<MockDirectiveHandler>> create(
|
|
std::chrono::milliseconds handlingTimeMs = DEFAULT_HANDLING_TIME_MS);
|
|
|
|
/**
|
|
* Constructor.
|
|
* @param handlingTimeMs The amount of time (in milliseconds) this handler takes to handle directives.
|
|
*/
|
|
MockDirectiveHandler(std::chrono::milliseconds handlingTimeMs);
|
|
|
|
/// Destructor.
|
|
~MockDirectiveHandler();
|
|
|
|
/**
|
|
* The functional part of mocking handleDirectiveImmediately().
|
|
* @param directive The directive to handle.
|
|
*/
|
|
void mockHandleDirectiveImmediately(std::shared_ptr<AVSDirective> directive);
|
|
|
|
/**
|
|
* The functional part of mocking preHandleDirective().
|
|
* @param directive The directive to pre-handle.
|
|
* @param result The result object to
|
|
*/
|
|
void mockPreHandleDirective(
|
|
std::shared_ptr<AVSDirective> directive,
|
|
std::shared_ptr<DirectiveHandlerResultInterface> result);
|
|
|
|
/**
|
|
* The functional part of mocking handleDirective().
|
|
* @param messageId The MessageId of the @c AVSDirective to handle.
|
|
*/
|
|
void mockHandleDirective(const std::string& messageId);
|
|
|
|
/**
|
|
* The functional part of mocking cancelDirective().
|
|
* @param directive The MessageId of the directive to cancel.
|
|
*/
|
|
void mockCancelDirective(const std::string& messageId);
|
|
|
|
/**
|
|
* The functional part of mocking shutdown().
|
|
*/
|
|
void mockShutdown();
|
|
|
|
/**
|
|
* Method for m_doHandleDirectiveThread. Waits a specified time before reporting completion.
|
|
* If cancelDirective() is called in the mean time, wake up and exit.
|
|
* @param messageId The messageId to pass to the observer when reporting completion.
|
|
*/
|
|
void doHandleDirective(const std::string& messageId);
|
|
|
|
/**
|
|
* Fail preHandleDirective() by calling onDirectiveError().
|
|
* @param directive The directive to simulate the failure of.
|
|
* @param result An object to receive the result of the handling operation.
|
|
*/
|
|
void doPreHandlingFailed(
|
|
std::shared_ptr<AVSDirective> directive,
|
|
std::shared_ptr<DirectiveHandlerResultInterface> result);
|
|
|
|
/**
|
|
* Fail handleDirective() by calling onDirectiveError().
|
|
* @param messageId The MessageId of the directive to simulate the failure of.
|
|
*/
|
|
void doHandlingFailed(const std::string& messageId);
|
|
|
|
/**
|
|
* Common shutdown code.
|
|
*/
|
|
void shutdownCommon();
|
|
|
|
/**
|
|
* Block until preHandleDirective() is called.
|
|
* @param timeout The max amount of time to wait (in milliseconds).
|
|
* @return @c true if preHandeDirective() was called before the timeout.
|
|
*/
|
|
bool waitUntilPreHandling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);
|
|
|
|
/**
|
|
* Block until handleDirective() is called.
|
|
* @param timeout The max amount of time to wait (in milliseconds).
|
|
* @return @c true if handeDirective() was called before the timeout.
|
|
*/
|
|
bool waitUntilHandling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);
|
|
|
|
/**
|
|
* Block until cancelDirective() is called.
|
|
* @param timeout The max amount of time to wait (in milliseconds).
|
|
* @return @c true if cancelDirective() was called before the timeout.
|
|
*/
|
|
bool waitUntilCanceling(std::chrono::milliseconds timeout = DEFAULT_DONE_TIMEOUT_MS);
|
|
|
|
/**
|
|
* Return whether shutdown() has been called.
|
|
* @return whether shutdown() has been called.
|
|
*/
|
|
bool isShuttingDown();
|
|
|
|
/// The amount of time (in milliseconds) handling a directive will take.
|
|
std::chrono::milliseconds m_handlingTimeMs;
|
|
|
|
/// Object used to specify the result of handling a directive.
|
|
std::shared_ptr<DirectiveHandlerResultInterface> m_result;
|
|
|
|
/// Thread to perform handleDirective() asynchronously.
|
|
std::thread m_doHandleDirectiveThread;
|
|
|
|
/// Mutex to protect m_isShuttingDown.
|
|
std::mutex m_mutex;
|
|
|
|
/// Whether shutdown() has been called.
|
|
bool m_isShuttingDown;
|
|
|
|
/// condition_variable use to wake doHandlingDirectiveThread.
|
|
std::condition_variable m_wakeNotifier;
|
|
|
|
/// Promise fulfilled when preHandleDirective() begins.
|
|
std::promise<void> m_preHandlingPromise;
|
|
|
|
/// Future to notify when preHandleDirective() begins.
|
|
std::future<void> m_preHandlingFuture;
|
|
|
|
/// Promise fulfilled when handleDirective() begins.
|
|
std::promise<void> m_handlingPromise;
|
|
|
|
/// Future to notify when handleDirective() begins.
|
|
std::future<void> m_handlingFuture;
|
|
|
|
/// Promise fulfilled when cancelDirective() begins.
|
|
std::promise<void> m_cancelingPromise;
|
|
|
|
/// Future to notify when cancelDirective() begins.
|
|
std::shared_future<void> m_cancelingFuture;
|
|
|
|
MOCK_METHOD1(handleDirectiveImmediately, void(std::shared_ptr<AVSDirective>));
|
|
MOCK_METHOD2(
|
|
preHandleDirective,
|
|
void(std::shared_ptr<AVSDirective>, std::shared_ptr<DirectiveHandlerResultInterface>));
|
|
MOCK_METHOD1(handleDirective, void(const std::string&));
|
|
MOCK_METHOD1(cancelDirective, void(const std::string&));
|
|
MOCK_METHOD0(shutdown, void());
|
|
};
|
|
|
|
class MockAttachmentManager : public AttachmentManagerInterface {
|
|
public:
|
|
MOCK_METHOD1(createAttachmentReader, std::future<std::shared_ptr<std::iostream>> (const std::string& attachmentId));
|
|
MOCK_METHOD2(createAttachment, void (const std::string& attachmentId, std::shared_ptr<std::iostream> attachment));
|
|
MOCK_METHOD1(releaseAttachment, void (const std::string& attachmentId));
|
|
};
|
|
|
|
|
|
std::shared_ptr<NiceMock<MockDirectiveHandler>> MockDirectiveHandler::create(std::chrono::milliseconds handlingTimeMs) {
|
|
auto result = std::make_shared<NiceMock<MockDirectiveHandler>>(handlingTimeMs);
|
|
ON_CALL(*result.get(), handleDirectiveImmediately(_)).WillByDefault(
|
|
Invoke(result.get(), &MockDirectiveHandler::mockHandleDirectiveImmediately));
|
|
ON_CALL(*result.get(), preHandleDirective(_, _)).WillByDefault(
|
|
Invoke(result.get(), &MockDirectiveHandler::mockPreHandleDirective));
|
|
ON_CALL(*result.get(), handleDirective(_)).WillByDefault(
|
|
Invoke(result.get(), &MockDirectiveHandler::mockHandleDirective));
|
|
ON_CALL(*result.get(), cancelDirective(_)).WillByDefault(
|
|
Invoke(result.get(), &MockDirectiveHandler::mockCancelDirective));
|
|
ON_CALL(*result.get(), shutdown()).WillByDefault(
|
|
Invoke(result.get(), &MockDirectiveHandler::mockShutdown));
|
|
return result;
|
|
}
|
|
|
|
MockDirectiveHandler::MockDirectiveHandler(std::chrono::milliseconds handlingTimeMs) :
|
|
m_handlingTimeMs{handlingTimeMs},
|
|
m_isShuttingDown{false},
|
|
m_preHandlingPromise{},
|
|
m_preHandlingFuture{m_preHandlingPromise.get_future()},
|
|
m_handlingPromise{},
|
|
m_handlingFuture{m_handlingPromise.get_future()},
|
|
m_cancelingPromise{},
|
|
m_cancelingFuture{m_cancelingPromise.get_future()} {
|
|
}
|
|
|
|
MockDirectiveHandler::~MockDirectiveHandler() {
|
|
}
|
|
|
|
void MockDirectiveHandler::mockHandleDirectiveImmediately(std::shared_ptr<AVSDirective> directive) {
|
|
ASSERT_FALSE(isShuttingDown());
|
|
m_handlingPromise.set_value();
|
|
}
|
|
|
|
void MockDirectiveHandler::mockPreHandleDirective(
|
|
std::shared_ptr<AVSDirective> directive,
|
|
std::shared_ptr<DirectiveHandlerResultInterface> result) {
|
|
ASSERT_FALSE(isShuttingDown());
|
|
m_result = result;
|
|
m_preHandlingPromise.set_value();
|
|
}
|
|
|
|
void MockDirectiveHandler::mockHandleDirective(const std::string& messageId) {
|
|
ASSERT_FALSE(isShuttingDown());
|
|
m_doHandleDirectiveThread = std::thread(&MockDirectiveHandler::doHandleDirective, this, messageId);
|
|
}
|
|
|
|
void MockDirectiveHandler::mockCancelDirective(const std::string& messageId) {
|
|
ASSERT_FALSE(isShuttingDown());
|
|
m_cancelingPromise.set_value();
|
|
shutdownCommon();
|
|
}
|
|
|
|
void MockDirectiveHandler::mockShutdown() {
|
|
ASSERT_TRUE(waitUntilCanceling(std::chrono::milliseconds(0)) || !isShuttingDown());
|
|
shutdownCommon();
|
|
}
|
|
|
|
void MockDirectiveHandler::doHandleDirective(const std::string& messageId) {
|
|
auto isShuttingDown = [this]() {
|
|
return m_isShuttingDown;
|
|
};
|
|
m_handlingPromise.set_value();
|
|
std::unique_lock<std::mutex> lock(m_mutex);
|
|
if (!m_wakeNotifier.wait_for(lock, m_handlingTimeMs, isShuttingDown)) {
|
|
m_result->setCompleted();
|
|
}
|
|
}
|
|
|
|
void MockDirectiveHandler::doPreHandlingFailed(
|
|
std::shared_ptr<AVSDirective> directive,
|
|
std::shared_ptr<DirectiveHandlerResultInterface> result) {
|
|
m_result = result;
|
|
m_result->setFailed("doPreHandlingFailed()");
|
|
m_preHandlingPromise.set_value();
|
|
}
|
|
|
|
void MockDirectiveHandler::doHandlingFailed(const std::string& messageId) {
|
|
m_result->setFailed("doHandlingFailed()");
|
|
m_handlingPromise.set_value();
|
|
}
|
|
|
|
void MockDirectiveHandler::shutdownCommon() {
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
m_isShuttingDown = true;
|
|
m_wakeNotifier.notify_all();
|
|
}
|
|
if (m_doHandleDirectiveThread.joinable()) {
|
|
m_doHandleDirectiveThread.join();
|
|
}
|
|
}
|
|
|
|
bool MockDirectiveHandler::waitUntilPreHandling(std::chrono::milliseconds timeout) {
|
|
return m_preHandlingFuture.wait_for(timeout) == std::future_status::ready;
|
|
}
|
|
|
|
bool MockDirectiveHandler::waitUntilHandling(std::chrono::milliseconds timeout) {
|
|
return m_handlingFuture.wait_for(timeout) == std::future_status::ready;
|
|
}
|
|
|
|
bool MockDirectiveHandler::waitUntilCanceling(std::chrono::milliseconds timeout) {
|
|
return m_cancelingFuture.wait_for(timeout) == std::future_status::ready;
|
|
}
|
|
|
|
bool MockDirectiveHandler::isShuttingDown() {
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
return m_isShuttingDown;
|
|
}
|
|
|
|
/// DirectiveSequencerTest
|
|
class DirectiveSequencerTest : public ::testing::Test {
|
|
public:
|
|
|
|
/// Constructor.
|
|
DirectiveSequencerTest();
|
|
|
|
/**
|
|
* Setup the DirectiveSequencerTest. Creates a DirectiveSequencer and initialized it with a DirectiveHandler
|
|
* that allows waiting for a final directive to be processed.
|
|
*/
|
|
void SetUp() override;
|
|
|
|
/**
|
|
* TearDown the DirectiveSequencerTest. Sends a Test.Done directive with the current dialogRequestId and
|
|
* waits for it to be handled before allowing the test to complete.
|
|
*/
|
|
void TearDown() override;
|
|
|
|
/**
|
|
* SetDialogRequestId(). Tests should use this method rather than m_sequencer->setDialogRequestId() so
|
|
* that @c TearDown() knows which @c DialogRequestId to use for the Test::Done directive.
|
|
* @param dialogRequestId The new value for DialogRequestId.
|
|
*/
|
|
void setDialogRequestId(std::string dialogRequestId);
|
|
|
|
/**
|
|
* Method to invoke when handleDirective() is invoked for the Test::Done directive.
|
|
* @param messageId The message ID of a directive previously passed to preHandleDirective().
|
|
*/
|
|
void notifyDone(std::string messageId);
|
|
|
|
/// The DialogRequestId to use for the Test::Done directive.
|
|
std::string m_latestDialogRequestId;
|
|
|
|
/// Handler to invoke for the Test::Done directive.
|
|
std::shared_ptr<MockDirectiveHandler> m_doneHandler;
|
|
|
|
/// The DirectiveSequencer to test.
|
|
std::shared_ptr<DirectiveSequencer> m_sequencer;
|
|
|
|
/// Promise fulfilled when the test is done.
|
|
std::promise<void> m_donePromise;
|
|
|
|
/// Future used to notify when the test is done.
|
|
std::future<void> m_doneFuture;
|
|
|
|
/// Mock object of AttachmentManagerInterface
|
|
std::shared_ptr<acl::AttachmentManagerInterface> m_mockAttachmentManager;
|
|
};
|
|
|
|
DirectiveSequencerTest::DirectiveSequencerTest() : m_donePromise{}, m_doneFuture{m_donePromise.get_future()} {
|
|
}
|
|
|
|
void DirectiveSequencerTest::SetUp() {
|
|
m_doneHandler = MockDirectiveHandler::create();
|
|
m_mockAttachmentManager = std::make_shared<MockAttachmentManager>();
|
|
m_sequencer = DirectiveSequencer::create(nullptr);
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_TEST, NAME_DONE}, {m_doneHandler, BlockingPolicy::BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
}
|
|
|
|
void DirectiveSequencerTest::TearDown() {
|
|
auto avsMessageHeader = std::make_shared<AVSMessageHeader>(NAMESPACE_TEST, NAME_DONE, MESSAGE_ID_DONE,
|
|
DIALOG_REQUEST_ID_DONE);
|
|
std::shared_ptr<AVSDirective> directive = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
EXPECT_CALL(*(m_doneHandler.get()), handleDirective(MESSAGE_ID_DONE)).WillOnce(
|
|
Invoke(this, &DirectiveSequencerTest::notifyDone));
|
|
m_sequencer->setDialogRequestId(DIALOG_REQUEST_ID_DONE);
|
|
m_sequencer->onDirective(directive);
|
|
m_doneFuture.wait_for(DEFAULT_DONE_TIMEOUT_MS);
|
|
m_sequencer->shutdown();
|
|
}
|
|
|
|
void DirectiveSequencerTest::setDialogRequestId(std::string dialogRequestId) {
|
|
m_latestDialogRequestId = dialogRequestId;
|
|
m_sequencer->setDialogRequestId(m_latestDialogRequestId);
|
|
}
|
|
|
|
void DirectiveSequencerTest::notifyDone(std::string messageId) {
|
|
m_donePromise.set_value();
|
|
}
|
|
|
|
/**
|
|
* Verify core DirectiveSequencerTest. Expect a new non-null instance of m_sequencer.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testCreateAndDoneTrigger) {
|
|
ASSERT_TRUE(m_sequencer);
|
|
}
|
|
|
|
/**
|
|
* Exercise sending a @c nullptr to @c onDirective. Expect that false is returned.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testNullptrDirective) {
|
|
ASSERT_FALSE(m_sequencer->onDirective(nullptr));
|
|
}
|
|
|
|
/**
|
|
* Send a directive with an empty DialogRequestId.
|
|
* Expect a call to handleDirectiveImmediately().
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testEmptyDialogRequestId) {
|
|
auto avsMessageHeader = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEAKER, NAME_SET_VOLUME, MESSAGE_ID_0);
|
|
std::shared_ptr<AVSDirective> directive = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
auto handler = MockDirectiveHandler::create();
|
|
EXPECT_CALL(*(handler.get()), handleDirectiveImmediately(directive)).Times(1);
|
|
EXPECT_CALL(*(handler.get()), preHandleDirective(_, _)).Times(0);
|
|
EXPECT_CALL(*(handler.get()), handleDirective(_)).Times(0);
|
|
EXPECT_CALL(*(handler.get()), cancelDirective(_)).Times(0);
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEAKER, NAME_SET_VOLUME}, {handler, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
m_sequencer->onDirective(directive);
|
|
ASSERT_TRUE(handler->waitUntilHandling());
|
|
}
|
|
|
|
/**
|
|
* Set handlers (NON_BLOCKING) for two namespace,name pairs. Then remove one and change the other. Send directives
|
|
* for each of the namespace,name pairs. Expect that the directive with no mapping is not seen by a handler that
|
|
* the one that still has a handler is handled.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testRemovingAndChangingHandlers) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEAKER, NAME_SET_VOLUME, MESSAGE_ID_0);
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_TEST, NAME_NON_BLOCKING, MESSAGE_ID_1);
|
|
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
auto handler0 = MockDirectiveHandler::create();
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(directive1)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(_, _)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(_)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(_, _)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(_)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEAKER, NAME_SET_VOLUME}, {handler0, BlockingPolicy::NON_BLOCKING}},
|
|
{{NAMESPACE_TEST, NAME_NON_BLOCKING}, {handler1, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEAKER, NAME_SET_VOLUME}, {nullptr, BlockingPolicy::NONE}},
|
|
{{NAMESPACE_TEST, NAME_NON_BLOCKING}, {handler0, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler0->waitUntilHandling());
|
|
}
|
|
|
|
/**
|
|
* Send a long running directive with an non-empty @c DialogRequestId and a BLOCKING policy. Expect a call to
|
|
* @c preHandleDirective() and a call to @c handleDirective(). The @c AVSDirective is the cancelled, triggering
|
|
* a call to cancelDirective() to close out the test.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testBlockingDirective) {
|
|
auto avsMessageHeader = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
std::shared_ptr<AVSDirective> directive = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
auto handler = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
EXPECT_CALL(*(handler.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler.get()), preHandleDirective(directive, _)).Times(1);
|
|
EXPECT_CALL(*(handler.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler.get()), cancelDirective(_)).Times(1);
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler, BlockingPolicy::BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive);
|
|
ASSERT_TRUE(handler->waitUntilHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_1);
|
|
ASSERT_TRUE(handler->waitUntilCanceling());
|
|
}
|
|
|
|
/**
|
|
* Send a long running @c AVSDirective with an non-empty @c DialogRequestId and a @c BLOCKING policy followed by
|
|
* a @c AVSDirective without a @c dialogRequestId. Expect that the second directive gets handled immediately
|
|
* and without waiting for the @c BLOCKING directive to complete.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testBlockingThenNonDialogDirective) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(
|
|
NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0, DIALOG_REQUEST_ID_0);
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(
|
|
UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST, m_mockAttachmentManager);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEAKER, NAME_SET_VOLUME, MESSAGE_ID_1);
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(
|
|
UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST, m_mockAttachmentManager);
|
|
|
|
auto handler0 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(1);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(directive1)).Times(1);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(_, _)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(_)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_SPEAKER, NAME_SET_VOLUME}, {handler1, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler1->waitUntilHandling());
|
|
ASSERT_TRUE(handler0->waitUntilHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_1);
|
|
ASSERT_TRUE(handler0->waitUntilCanceling());
|
|
}
|
|
|
|
/**
|
|
* Send a directive with an non-empty @c DialogRequestId and a @c BLOCKING policy, to an @c DirectiveHandler with a
|
|
* long handling time. Once the @c DirectiveHandler is handling the @c AVSDirective, set the @c DirectiveSequencer's
|
|
* @c DialogRequestId (simulating an outgoing @c SpeechRecognizer request). Expect a call to
|
|
* @c preHandleDirective(@cAVSDirective) a call to @c handleDirective(@c MessageId, @c DirectiveHandlingResult),
|
|
* and a call to @c cancelDirective(@c MessageId).
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testBargeIn) {
|
|
auto avsMessageHeader = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
std::shared_ptr<AVSDirective> directive = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
auto handler = MockDirectiveHandler::create(std::chrono::milliseconds(LONG_HANDLING_TIME_MS));
|
|
|
|
|
|
EXPECT_CALL(*(handler.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler.get()), preHandleDirective(directive, _)).Times(1);
|
|
EXPECT_CALL(*(handler.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler.get()), cancelDirective(MESSAGE_ID_0)).Times(1);
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler, BlockingPolicy::BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive);
|
|
ASSERT_TRUE(handler->waitUntilHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_1);
|
|
ASSERT_TRUE(handler->waitUntilCanceling());
|
|
}
|
|
|
|
/**
|
|
* Send an @c AVSDirective with an non-empty @c DialogRequestId and a @c BLOCKING policy followed by two
|
|
* @c NON_BLOCKING @c AVSDirectives with the same @c DialogRequestId. Expect a call to
|
|
* @c preHandleDirective(@c AVSDirective) and a call to @c handleDirective() for each @c AVSDirective.
|
|
* Along the way we set the DialogRequestId to the same value to verify that that setting it to the
|
|
* current value does not cancel queued directives.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testBlockingThenNonBockingOnSameDialogId) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_AUDIO_PLAYER, NAME_PLAY, MESSAGE_ID_1,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader2 = std::make_shared<AVSMessageHeader>(NAMESPACE_TEST, NAME_NON_BLOCKING, MESSAGE_ID_2,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive2 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader2, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
auto handler0 = MockDirectiveHandler::create();
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
auto handler2 = MockDirectiveHandler::create();
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler1, BlockingPolicy::NON_BLOCKING}},
|
|
{{NAMESPACE_TEST, NAME_NON_BLOCKING}, {handler2, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(directive1, _)).Times(1);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_1)).Times(1);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0);
|
|
|
|
EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(_)).Times(0);
|
|
EXPECT_CALL(*(handler2.get()), preHandleDirective(directive2, _)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), handleDirective(MESSAGE_ID_2)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), cancelDirective(_)).Times(0);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive2);
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
ASSERT_TRUE(handler2->waitUntilHandling());
|
|
}
|
|
|
|
/**
|
|
* Send a long-running @c BLOCKING @c AVSDirective followed by a @c NON_BLOCKING @c AVSDirective with the same
|
|
* @c DialogRequestId. Once the first @c AVSDirective is being handled and the second @c AVSDirective is being
|
|
* preHandled send a new @c AVDirective with a different @c DialogRequestId to simulate 'barge-in'. Expect that
|
|
* the first two directives will be cancelled and the third one will be handled (and then cancelled at the
|
|
* end by setting the dialogRequestId to close out the test).
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testThatBargeInDropsSubsequentDirectives) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_AUDIO_PLAYER, NAME_PLAY, MESSAGE_ID_1,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader2 = std::make_shared<AVSMessageHeader>(NAMESPACE_TEST, NAME_BLOCKING, MESSAGE_ID_2,
|
|
DIALOG_REQUEST_ID_1);
|
|
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive2 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader2, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
|
|
auto handler0 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
auto handler2 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler1, BlockingPolicy::NON_BLOCKING}},
|
|
{{NAMESPACE_TEST, NAME_BLOCKING}, {handler2, BlockingPolicy::BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(directive0)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(MESSAGE_ID_0)).Times(1);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(directive1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(directive1, _)).Times(1);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(MESSAGE_ID_1)).Times(1);
|
|
|
|
EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(directive2)).Times(0);
|
|
EXPECT_CALL(*(handler2.get()), preHandleDirective(directive2, _)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), handleDirective(MESSAGE_ID_2)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), cancelDirective(MESSAGE_ID_2)).Times(1);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler0->waitUntilHandling());
|
|
ASSERT_TRUE(handler1->waitUntilPreHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_1);
|
|
m_sequencer->onDirective(directive2);
|
|
ASSERT_TRUE(handler2->waitUntilHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_2);
|
|
ASSERT_TRUE(handler2->waitUntilCanceling());
|
|
}
|
|
|
|
/**
|
|
* Send a long-running @c BLOCKING @c AVSDirective followed by a @c NON_BLOCKING @c AVSDirective with the same
|
|
* @c DialogRequestId. When the first @c AVSDirective is preHandled, report a failure via @c setFailed().
|
|
* Expect that the first @c AVSDirective will not be cancelled and that the second @c AVSDirective will be dropped
|
|
* entirely.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testPreHandleDirectiveError) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_AUDIO_PLAYER, NAME_PLAY, MESSAGE_ID_1,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
|
|
|
|
auto handler0 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler1, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(directive0)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).WillOnce(
|
|
Invoke(handler0.get(), &MockDirectiveHandler::doPreHandlingFailed));
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(MESSAGE_ID_0)).Times(0);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(directive1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(directive1, _)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(MESSAGE_ID_1)).Times(0);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler0->waitUntilPreHandling());
|
|
}
|
|
|
|
/**
|
|
* Send a long-running @c BLOCKING @c AVSDirective followed by a @c NON_BLOCKING directive with the same
|
|
* @c DialogRequestId. When the first @c AVSDirective is handled, report a failure via @c setFailed().
|
|
* Expect that the first @c AVSDirective will not be cancelled and that the second @c AVSDirective may be
|
|
* dropped before @c preHandleDirective() is called, and that if not, it will be cancelled.
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testHandleDirectiveError) {
|
|
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_AUDIO_PLAYER, NAME_PLAY, MESSAGE_ID_1,
|
|
DIALOG_REQUEST_ID_0);
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
|
|
auto handler0 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler1, BlockingPolicy::NON_BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(directive0)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).WillOnce(
|
|
Invoke(handler0.get(), &MockDirectiveHandler::doHandlingFailed));
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(MESSAGE_ID_0)).Times(0);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(directive1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(directive1, _)).Times(AtMost(1));
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_1)).Times(0);;
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(MESSAGE_ID_1)).Times(AtMost(1));
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler0->waitUntilHandling());
|
|
}
|
|
|
|
/**
|
|
* Send a long-running @c BLOCKING @c AVSDirective followed by a @c NON_BLOCKING directive with the same
|
|
* @c DialogRequestId. Once they have reached the handling and preHandling stages, respectively, call
|
|
* setDirectiveHandlers(), swapping the handlers and policies for the two outstanding @c AVSDirectives.
|
|
* Expect that both of the outstanding @c AVSDirectives will be cancelled. Then send an @c BLOCKING
|
|
* @c AVSDirective whose handler mapping has not changed. Expect that that last @c AVSDirective will
|
|
* be preHandled and handled. The last @c AVSDirectiveis long running and in the end is cancelled to
|
|
* close out the test.
|
|
|
|
*/
|
|
TEST_F(DirectiveSequencerTest, testSetDirectiveHandlersWhileHandlingDirectives) {
|
|
auto avsMessageHeader0 = std::make_shared<AVSMessageHeader>(NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK, MESSAGE_ID_0,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader1 = std::make_shared<AVSMessageHeader>(NAMESPACE_AUDIO_PLAYER, NAME_PLAY, MESSAGE_ID_1,
|
|
DIALOG_REQUEST_ID_0);
|
|
|
|
auto avsMessageHeader2 = std::make_shared<AVSMessageHeader>(NAMESPACE_TEST, NAME_BLOCKING, MESSAGE_ID_2,
|
|
DIALOG_REQUEST_ID_1);
|
|
|
|
std::shared_ptr<AVSDirective> directive0 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader0, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive1 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader1, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
std::shared_ptr<AVSDirective> directive2 = AVSDirective::create(UNPARSED_DIRECTIVE, avsMessageHeader2, PAYLOAD_TEST,
|
|
m_mockAttachmentManager);
|
|
|
|
|
|
auto handler0 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
auto handler1 = MockDirectiveHandler::create();
|
|
auto handler2 = MockDirectiveHandler::create(LONG_HANDLING_TIME_MS);
|
|
|
|
auto ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler1, BlockingPolicy::NON_BLOCKING}},
|
|
{{NAMESPACE_TEST, NAME_BLOCKING}, {handler2, BlockingPolicy::BLOCKING}}
|
|
});
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(directive0)).Times(0);
|
|
EXPECT_CALL(*(handler0.get()), preHandleDirective(directive0, _)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0)).Times(1);
|
|
EXPECT_CALL(*(handler0.get()), cancelDirective(MESSAGE_ID_0)).Times(1);
|
|
|
|
EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(directive1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), preHandleDirective(directive1, _)).Times(1);
|
|
EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_1)).Times(0);
|
|
EXPECT_CALL(*(handler1.get()), cancelDirective(MESSAGE_ID_1)).Times(1);
|
|
|
|
EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(directive2)).Times(0);
|
|
EXPECT_CALL(*(handler2.get()), preHandleDirective(directive2, _)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), handleDirective(MESSAGE_ID_2)).Times(1);
|
|
EXPECT_CALL(*(handler2.get()), cancelDirective(MESSAGE_ID_2)).Times(1);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_0);
|
|
m_sequencer->onDirective(directive0);
|
|
m_sequencer->onDirective(directive1);
|
|
ASSERT_TRUE(handler0->waitUntilHandling());
|
|
ASSERT_TRUE(handler1->waitUntilPreHandling());
|
|
|
|
ready = m_sequencer->setDirectiveHandlers({
|
|
{{NAMESPACE_SPEECH_SYNTHESIZER, NAME_SPEAK}, {handler1, BlockingPolicy::NON_BLOCKING}},
|
|
{{NAMESPACE_AUDIO_PLAYER, NAME_PLAY}, {handler0, BlockingPolicy::BLOCKING}},
|
|
{{NAMESPACE_TEST, NAME_BLOCKING}, {handler2, BlockingPolicy::BLOCKING}}
|
|
});
|
|
|
|
ASSERT_TRUE(handler1->waitUntilCanceling());
|
|
ASSERT_WAIT_FOR_TIMEOUT(ready);
|
|
|
|
setDialogRequestId(DIALOG_REQUEST_ID_1);
|
|
m_sequencer->onDirective(directive2);
|
|
ASSERT_TRUE(handler2->waitUntilHandling());
|
|
setDialogRequestId(DIALOG_REQUEST_ID_2);
|
|
ASSERT_TRUE(handler2->waitUntilCanceling());
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace adsl
|
|
} // namespace alexaClientSDK
|