269 lines
11 KiB
C++
269 lines
11 KiB
C++
/*
|
|
* Copyright 2018 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 <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <algorithm>
|
|
#include <list>
|
|
#include <memory>
|
|
|
|
#include <AVSCommon/Utils/Configuration/ConfigurationNode.h>
|
|
|
|
#include "EqualizerImplementations/SDKConfigEqualizerConfiguration.h"
|
|
|
|
namespace alexaClientSDK {
|
|
namespace equalizer {
|
|
namespace test {
|
|
|
|
using namespace ::testing;
|
|
using namespace avsCommon::sdkInterfaces::audio;
|
|
using namespace avsCommon::utils::configuration;
|
|
|
|
/// Alias for JSON stream type used in @c ConfigurationNode initialization
|
|
using JSONStream = std::vector<std::shared_ptr<std::istream>>;
|
|
|
|
/// JSON configuration with all bands defined, but not all supported.
|
|
const std::string JSON_LIMITED_BANDS = R"({"bands":{"BASS":false, "MIDRANGE":false, "TREBLE":true}})";
|
|
/// JSON configuration with a limited set of bands defined.
|
|
const std::string JSON_LIMITED_BANDS_ONE_MISSING = R"({"bands":{"BASS":false, "MIDRANGE":false}})";
|
|
/// JSON configuration with a an empty supported bands branch.
|
|
const std::string JSON_NO_BANDS_PROVIDED = R"({"bands":{}})";
|
|
/// JSON configuration with a an invalid band listed as supported.
|
|
const std::string JSON_INVALID_BAND = R"({"bands":{"DEEPBASS":true}})";
|
|
/// JSON configuration with a one mode defined and supported.
|
|
const std::string JSON_ONE_MODE_MENTIONED_ENABLED = R"({"modes":{"NIGHT": true}})";
|
|
/// JSON configuration with a one mode defined but unsupported.
|
|
const std::string JSON_ONE_MODE_MENTIONED_DISABLED = R"({"modes":{"NIGHT": false}})";
|
|
/// JSON configuration with an empty default state branch.
|
|
const std::string JSON_EMPTY_DEFAULT_STATE_BRANCH = R"({"defaultState":{}})";
|
|
/// JSON configuration with a default supported mode provided.
|
|
const std::string JSON_DEFAULT_MODE_SUPPORTED = R"({"modes": {"NIGHT":true}, "defaultState":{"mode":"NIGHT"}})";
|
|
/// JSON configuration with a default unsupported mode provided.
|
|
const std::string JSON_DEFAULT_MODE_UNSUPPORTED = R"({"defaultState":{"mode":"NIGHT"}})";
|
|
/// JSON configuration with a missing band levels in default state.
|
|
const std::string JSON_DEFAULT_STATE_MISSING_BANDS = R"({"defaultState":{"bands":{"BASS": 1}}})";
|
|
/// JSON configuration with all band defined but unsupported and empty bands branch in default state.s
|
|
const std::string JSON_DEFAULT_STATE_BANDS_EMPTY_NO_BANDS_SUPPORTED =
|
|
R"({"bands":{"BASS":false, "MIDRANGE":false, "TREBLE":false}, "defaultState":{"bands":{}}})";
|
|
|
|
/**
|
|
* Test fixture for @c SDKConfigEqualizerConfiguration tests.
|
|
*/
|
|
class SDKConfigEqualizerConfigurationTest : public ::testing::Test {
|
|
public:
|
|
protected:
|
|
/**
|
|
* Test teardown.
|
|
*/
|
|
void TearDown() override;
|
|
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
SDKConfigEqualizerConfigurationTest();
|
|
|
|
protected:
|
|
};
|
|
|
|
SDKConfigEqualizerConfigurationTest::SDKConfigEqualizerConfigurationTest() {
|
|
}
|
|
|
|
void SDKConfigEqualizerConfigurationTest::TearDown() {
|
|
// Cleanup the configuration so that next intialize() will work.
|
|
ConfigurationNode::uninitialize();
|
|
}
|
|
|
|
/*
|
|
* Utility function to generate @c ConfigurationNode from JSON string.
|
|
*/
|
|
static ConfigurationNode generateConfigFromJSON(std::string json) {
|
|
auto stream = std::shared_ptr<std::stringstream>(new std::stringstream(json));
|
|
JSONStream jsonStream({stream});
|
|
ConfigurationNode::initialize(jsonStream);
|
|
return ConfigurationNode::getRoot();
|
|
}
|
|
|
|
// Test creation with an empty configuration
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, providedEmptyConfig_shouldSucceed) {
|
|
auto defaultConfig = InMemoryEqualizerConfiguration::createDefault();
|
|
ConfigurationNode rootNode;
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
}
|
|
|
|
// Empty configuration should lead to default values.
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, providedEmptyConfig_shouldUseDefaultConfig) {
|
|
auto defaultConfig = InMemoryEqualizerConfiguration::createDefault();
|
|
ConfigurationNode rootNode;
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
|
|
EXPECT_EQ(defaultConfig->getMinBandLevel(), config->getMinBandLevel());
|
|
EXPECT_EQ(defaultConfig->getMaxBandLevel(), config->getMaxBandLevel());
|
|
|
|
EXPECT_EQ(defaultConfig->getSupportedBands(), config->getSupportedBands());
|
|
EXPECT_EQ(defaultConfig->getSupportedModes(), config->getSupportedModes());
|
|
|
|
EXPECT_EQ(defaultConfig->getDefaultState().mode, config->getDefaultState().mode);
|
|
EXPECT_EQ(defaultConfig->getDefaultState().bandLevels, config->getDefaultState().bandLevels);
|
|
}
|
|
|
|
// Test the case when only some of the bands supported
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, providedLimitedBandsDefined_shouldSucceed) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_LIMITED_BANDS);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::BASS));
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::MIDRANGE));
|
|
// This depends on hardcoded defaults we have
|
|
EXPECT_TRUE(config->isBandSupported(EqualizerBand::TREBLE));
|
|
}
|
|
|
|
// Test the case when only some of the bands supported, one of them is not explicitly mentioned.
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, providedLimitedBandsOneMissing_shouldSucceed) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_LIMITED_BANDS_ONE_MISSING);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::BASS));
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::MIDRANGE));
|
|
EXPECT_EQ(
|
|
config->isBandSupported(EqualizerBand::TREBLE),
|
|
SDKConfigEqualizerConfiguration::BAND_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
}
|
|
|
|
// Test empty bands branch behavior
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, havingEmptyBandList_shouldUseHardDefaults) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_NO_BANDS_PROVIDED);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
|
|
EXPECT_EQ(
|
|
config->isBandSupported(EqualizerBand::BASS),
|
|
SDKConfigEqualizerConfiguration::BAND_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isBandSupported(EqualizerBand::MIDRANGE),
|
|
SDKConfigEqualizerConfiguration::BAND_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isBandSupported(EqualizerBand::TREBLE),
|
|
SDKConfigEqualizerConfiguration::BAND_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
}
|
|
|
|
// Test invalid band listed in supported bands branch
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, havingOnlyInvalidBand_shouldSucceedAndSupportNone) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_INVALID_BAND);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::BASS));
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::MIDRANGE));
|
|
EXPECT_FALSE(config->isBandSupported(EqualizerBand::TREBLE));
|
|
}
|
|
|
|
// Test modes branch containing one mode enabled
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, oneModeDefinedAndEnabled_shouldPutOthersToDefaults) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_ONE_MODE_MENTIONED_ENABLED);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
|
|
EXPECT_TRUE(config->isModeSupported(EqualizerMode::NIGHT));
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::TV),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::SPORT),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::MUSIC),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::MOVIE),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
}
|
|
|
|
// Test modes branch containing one mode disabled
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, oneModeDefinedAndDisabled_shouldPutOthersToDefaults) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_ONE_MODE_MENTIONED_DISABLED);
|
|
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
|
|
EXPECT_FALSE(config->isModeSupported(EqualizerMode::NIGHT));
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::TV),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::SPORT),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::MUSIC),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
EXPECT_EQ(
|
|
config->isModeSupported(EqualizerMode::MOVIE),
|
|
SDKConfigEqualizerConfiguration::MODE_IS_SUPPORTED_IF_MISSING_IN_CONFIG);
|
|
}
|
|
|
|
// Test the empty default state branch
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, givenEmptyDefaultStateBranchEmpty_shouldUseHardDefaults) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_EMPTY_DEFAULT_STATE_BRANCH);
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
auto defaultConfig = InMemoryEqualizerConfiguration::createDefault();
|
|
|
|
EXPECT_EQ(config->getDefaultState().mode, defaultConfig->getDefaultState().mode);
|
|
EXPECT_EQ(defaultConfig->getDefaultState().bandLevels, config->getDefaultState().bandLevels);
|
|
}
|
|
|
|
// Test default state with supported mode
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, givenSupportedDefaultMode_shouldSucceed) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_DEFAULT_MODE_SUPPORTED);
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
|
|
EXPECT_EQ(config->getDefaultState().mode, EqualizerMode::NIGHT);
|
|
}
|
|
|
|
// Test default state with unsupported mode
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, givenUnsupportedDefaultMode_shouldFail) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_DEFAULT_MODE_UNSUPPORTED);
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, IsNull());
|
|
}
|
|
|
|
// Test not all supported bands being provided in default state
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, havingNotAllBandsInDefaultState_shouldFail) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_DEFAULT_STATE_MISSING_BANDS);
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, IsNull());
|
|
}
|
|
|
|
// Test empty default state bands while not bands supported
|
|
TEST_F(SDKConfigEqualizerConfigurationTest, havingNoBandsDefinedInDefaultStateWithNoBandsSupported_shouldSucceed) {
|
|
ConfigurationNode rootNode = generateConfigFromJSON(JSON_DEFAULT_STATE_BANDS_EMPTY_NO_BANDS_SUPPORTED);
|
|
auto config = SDKConfigEqualizerConfiguration::create(rootNode);
|
|
ASSERT_THAT(config, NotNull());
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace equalizer
|
|
} // namespace alexaClientSDK
|