// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/public/cpp/app_list/app_list_config_provider.h"
#include <string>
#include <vector>
#include "ash/constants/ash_features.h"
#include "ash/public/cpp/app_list/app_list_config.h"
#include "ash/public/cpp/app_list/app_list_features.h"
#include "base/containers/contains.h"
#include "base/ranges/algorithm.h"
#include "base/test/scoped_feature_list.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
namespace {
// The expected number of columns in the tablet app list apps grid.
constexpr int kPreferredGridColumnsForWorkArea = 5;
// Does sanity check on apps grid item tile dimensions in config. On error, it
// causes test failure with additional |scoped_trace| message.
// |error_margin|: Allowed error margin when comparing vertical dimensions. Used
// for scaled app list config (to account for possible rounding
// errors).
void SanityCheckGridTileDimensions(AppListConfig* config, int error_margin) {
const int icon_top =
(config->grid_tile_height() - config->grid_icon_bottom_padding() -
config->grid_icon_dimension()) /
2;
// The app list item icon top should be within the tile bounds.
EXPECT_GE(icon_top, 0);
const int icon_bottom = icon_top + config->grid_icon_dimension();
const int title_top = config->grid_tile_height() -
config->grid_title_bottom_padding() -
config->app_title_font().GetHeight();
// Icon should not overlap with title.
EXPECT_LE(icon_bottom, title_top + error_margin);
// Icon should fit within available height.
EXPECT_LE(icon_bottom,
config->grid_tile_height() - config->grid_icon_bottom_padding());
// Icon should fit in the tile width.
EXPECT_LE(config->grid_icon_dimension(), config->grid_tile_width());
const int folder_icon_top =
(config->grid_tile_height() - config->grid_icon_bottom_padding() -
config->folder_icon_dimension()) /
2;
// The app list folder icon top should be within the tile bounds.
EXPECT_GE(folder_icon_top, 0);
// Unclipped folder icon should not overlap with title.
const int folder_icon_bottom =
folder_icon_top + config->folder_icon_dimension();
EXPECT_LE(folder_icon_bottom, title_top + error_margin);
// Unclipped folder icon should fit within available height.
EXPECT_LE(folder_icon_bottom,
config->grid_tile_height() - config->grid_icon_bottom_padding());
// Unclipped folder icon should fit into tile width.
EXPECT_LE(config->folder_icon_dimension(), config->grid_tile_width());
}
class TestAppListConfigProviderObserver
: public AppListConfigProvider::Observer {
public:
TestAppListConfigProviderObserver() = default;
TestAppListConfigProviderObserver(const TestAppListConfigProviderObserver&) =
delete;
TestAppListConfigProviderObserver& operator=(
const TestAppListConfigProviderObserver&) = delete;
~TestAppListConfigProviderObserver() override = default;
// AppListConfigProvider::Observer:
void OnAppListConfigCreated(ash::AppListConfigType config_type) override {
ASSERT_FALSE(base::Contains(created_types_, config_type));
created_types_.push_back(config_type);
}
const std::vector<ash::AppListConfigType>& created_types() const {
return created_types_;
}
void ClearCreatedTypes() { created_types_.clear(); }
private:
std::vector<ash::AppListConfigType> created_types_;
};
} // namespace
class AppListConfigProviderTest : public testing::Test {
public:
AppListConfigProviderTest() = default;
~AppListConfigProviderTest() override = default;
void SetUp() override {
// AppListConfigProvider is base::NoDestruct, which means it may not be
// cleared between test runs - clear the registry to ensure this test starts
// with the clean app list config registry.
AppListConfigProvider::Get().ResetForTesting();
AppListConfigProvider::Get().AddObserver(®istry_observer_);
}
void TearDown() override {
AppListConfigProvider::Get().RemoveObserver(®istry_observer_);
AppListConfigProvider::Get().ResetForTesting();
}
void VerifyScaledConfig(const AppListConfig& base_config,
AppListConfig* config,
float scale_x) {
ASSERT_TRUE(config);
EXPECT_EQ(base_config.type(), config->type());
EXPECT_EQ(scale_x, config->scale_x());
EXPECT_EQ(std::round(base_config.grid_tile_width() * scale_x),
config->grid_tile_width());
EXPECT_EQ(base_config.grid_tile_height(), config->grid_tile_height());
auto get_grid_title_height = [](const AppListConfig* config) {
return config->grid_tile_height() - config->grid_title_top_padding() -
config->grid_title_bottom_padding();
};
EXPECT_EQ(get_grid_title_height(&base_config),
get_grid_title_height(config));
SanityCheckGridTileDimensions(config, 1);
}
protected:
TestAppListConfigProviderObserver registry_observer_;
};
// Tests GetConfigForType behavior.
TEST_F(AppListConfigProviderTest, ConfigGetters) {
std::vector<AppListConfigType> test_cases = {AppListConfigType::kRegular,
AppListConfigType::kDense};
std::set<AppListConfigType> created_types;
for (const auto& config_type : test_cases) {
SCOPED_TRACE(static_cast<int>(config_type));
// Calling GetConfigForType with false |can_create| will not create a new
// config.
EXPECT_FALSE(AppListConfigProvider::Get().GetConfigForType(
config_type, false /*can_create*/));
EXPECT_EQ(std::vector<AppListConfigType>(),
registry_observer_.created_types());
// Calling GetConfigForType with true |can_create| will create a new config
// (if not previously created), and it will notify observers a config was
// created.
const AppListConfig* config = AppListConfigProvider::Get().GetConfigForType(
config_type, true /*can_create*/);
ASSERT_TRUE(config);
created_types.insert(config_type);
EXPECT_EQ(config_type, config->type());
const std::vector<AppListConfigType> expected_created_types = {config_type};
EXPECT_EQ(expected_created_types, registry_observer_.created_types());
// Subsequent calls to GetConfigForType will return previously created
// config, and will not notify observers of config creation.
EXPECT_EQ(config, AppListConfigProvider::Get().GetConfigForType(config_type,
false));
EXPECT_EQ(config,
AppListConfigProvider::Get().GetConfigForType(config_type, true));
EXPECT_EQ(expected_created_types, registry_observer_.created_types());
EXPECT_EQ(created_types,
AppListConfigProvider::Get().GetAvailableConfigTypes());
registry_observer_.ClearCreatedTypes();
}
}
// Tests calling CreateForFullscreenAppList creates the appropriate app list
// configuration depending on display size.
TEST_F(AppListConfigProviderTest, CreateConfigByDisplayWorkArea) {
// NOTE: The `available_size` are arbitrary values large enough so the
// returned app list config does not get scaled down (i.e. large enough so
// they can fit an apps grid with default sized-items).
const struct TestCase {
gfx::Size work_area_size;
gfx::Size available_size;
AppListConfigType config_type;
} test_cases[] = {
{gfx::Size(900, 500), gfx::Size(788, 321), AppListConfigType::kDense},
{gfx::Size(540, 900), gfx::Size(428, 704), AppListConfigType::kDense},
{gfx::Size(960, 600), gfx::Size(848, 412), AppListConfigType::kDense},
{gfx::Size(1100, 700), gfx::Size(988, 504), AppListConfigType::kRegular},
{gfx::Size(600, 960), gfx::Size(488, 764), AppListConfigType::kDense},
{gfx::Size(700, 1100), gfx::Size(588, 904), AppListConfigType::kRegular},
{gfx::Size(1200, 768), gfx::Size(1088, 572), AppListConfigType::kRegular},
{gfx::Size(768, 1200), gfx::Size(656, 1004),
AppListConfigType::kRegular}};
for (const auto& test_case : test_cases) {
SCOPED_TRACE(::testing::Message()
<< "Size: " << test_case.work_area_size.ToString()
<< ", expected config type: "
<< static_cast<int>(test_case.config_type));
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
test_case.work_area_size, kPreferredGridColumnsForWorkArea,
test_case.available_size, nullptr);
ASSERT_TRUE(config.get());
EXPECT_EQ(test_case.config_type, config->type());
EXPECT_EQ(1, config->scale_x());
SanityCheckGridTileDimensions(config.get(), 0);
// Verify that AppListConfigProvider now provides the created config type.
EXPECT_TRUE(AppListConfigProvider::Get().GetConfigForType(
test_case.config_type, false));
// NOTE: While a specific config might be expected in more than one test
// case, it should only get reported as created once - given that the
// observed created types are not cleared for |registry_observer_| between
// test cases, the "observed" count for |test_case.config_type| should
// always be 1.
EXPECT_EQ(1, base::ranges::count(registry_observer_.created_types(),
test_case.config_type));
// Verify CreateForAppListWidget returns nullptr if the created config would
// be the same as |config|.
EXPECT_FALSE(AppListConfigProvider::Get().CreateForTabletAppList(
test_case.work_area_size, kPreferredGridColumnsForWorkArea,
test_case.available_size, config.get()));
}
}
// Tests whether CreateForAppListWidget returns a new config depending on the
// value of the old config passed to the method.
TEST_F(AppListConfigProviderTest,
CreateConfigByDisplayWorkAreaWithNonNullConfig) {
// Create initial configuration.
gfx::Size work_area(1200, 768);
gfx::Size available_size(1088, 572);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size, nullptr);
ASSERT_TRUE(config);
EXPECT_EQ(AppListConfigType::kRegular, config->type());
// Verify CreateForAppListWidget returns nullptr if the created config would
// be the same as `config`.
work_area = gfx::Size(768, 1200);
available_size = gfx::Size(656, 1004);
EXPECT_FALSE(AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
config.get()));
// Create different config.
work_area = gfx::Size(960, 600);
available_size = gfx::Size(848, 412);
std::unique_ptr<AppListConfig> updated_config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
config.get());
ASSERT_TRUE(updated_config);
EXPECT_EQ(AppListConfigType::kDense, updated_config->type());
}
TEST_F(AppListConfigProviderTest,
CreateScaledConfigByDisplayWorkAreaRegularLandscape) {
// The available grid size fits the grid - created config is not scaled.
const gfx::Size work_area(1200, 768);
const gfx::Size initial_available_size(1088, 572);
std::unique_ptr<AppListConfig> base_config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, initial_available_size,
nullptr);
ASSERT_TRUE(base_config.get());
ASSERT_EQ(AppListConfigType::kRegular, base_config->type());
ASSERT_EQ(1, base_config->scale_x());
const int kMinGridWidth =
base_config->grid_tile_width() * kPreferredGridColumnsForWorkArea;
{
SCOPED_TRACE("Horizontal scaling");
// Reduce available width so the grid scales down horizontally.
const gfx::Size available_size(480, initial_available_size.height());
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 480.0f / kMinGridWidth);
}
{
SCOPED_TRACE("Vertical scaling");
// Reduce available height so the grid doesn't fit `preferred_rows` - the
// config should not be scaled, as apps grid is expected to reduce the
// number of visible rows in this case.
const gfx::Size available_size(initial_available_size.width(), 400);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 1);
}
{
SCOPED_TRACE("Horizontal and vertical scaling");
// Reduce both available width and height, and expect the grid to scale down
// horizontally only.
const gfx::Size available_size(480, 400);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 480.0f / kMinGridWidth);
}
}
TEST_F(AppListConfigProviderTest,
CreateScaledConfigByDisplayWorkAreaDenseLandscape) {
// The available grid size fits the grid - created config is not scaled.
const gfx::Size work_area(960, 600);
const gfx::Size initial_available_size(848, 412);
std::unique_ptr<AppListConfig> base_config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, initial_available_size,
nullptr);
ASSERT_TRUE(base_config.get());
ASSERT_EQ(AppListConfigType::kDense, base_config->type());
ASSERT_EQ(1, base_config->scale_x());
const int kMinGridWidth =
base_config->grid_tile_width() * kPreferredGridColumnsForWorkArea;
{
SCOPED_TRACE("Horizontal scaling");
// Reduce available width so the grid scales down horizontally.
const gfx::Size available_size(300, initial_available_size.height());
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 300.0f / kMinGridWidth);
}
{
SCOPED_TRACE("Vertical scaling");
// Reduce available height so the grid doesn't fit `preferred_rows` - the
// config should not be scaled, as apps grid is expected to reduce the
// number of visible rows in this case.
const gfx::Size available_size(initial_available_size.width(), 200);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 1);
}
{
SCOPED_TRACE("Horizontal and vertical scaling");
// Reduce both available width and height, and expect the grid to scale down
// horizontally only.
const gfx::Size available_size(300, 200);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 300.0f / kMinGridWidth);
}
}
TEST_F(AppListConfigProviderTest,
CreateScaledConfigByDisplayWorkAreaRegularPortrait) {
// The available grid size fits the grid - created config is not scaled.
const gfx::Size work_area(768, 1200);
const gfx::Size initial_available_size(656, 1004);
std::unique_ptr<AppListConfig> base_config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, initial_available_size,
nullptr);
ASSERT_TRUE(base_config.get());
ASSERT_EQ(AppListConfigType::kRegular, base_config->type());
ASSERT_EQ(1, base_config->scale_x());
const int kMinGridWidth =
base_config->grid_tile_width() * kPreferredGridColumnsForWorkArea;
{
SCOPED_TRACE("Horizontal scaling");
// Reduce available width so the grid scales down horizontally.
const gfx::Size available_size(440, initial_available_size.height());
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 440.0f / kMinGridWidth);
}
{
SCOPED_TRACE("Vertical scaling");
// Reduce available height so the grid doesn't fit `preferred_rows` - the
// config should not be scaled, as apps grid is expected to reduce the
// number of visible rows in this case.
const gfx::Size available_size(initial_available_size.width(), 532);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 1);
}
{
SCOPED_TRACE("Horizontal and vertical scaling");
// Reduce both available width and height, and expect the grid to scale down
// horizontally only.
const gfx::Size available_size(440, 532);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 440.0f / kMinGridWidth);
}
}
TEST_F(AppListConfigProviderTest,
CreateScaledConfigByDisplayWorkAreaDensePortrait) {
// The available grid size fits the grid - created config is not scaled.
const gfx::Size work_area(600, 960);
const gfx::Size initial_available_size(488, 764);
std::unique_ptr<AppListConfig> base_config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, initial_available_size,
nullptr);
ASSERT_TRUE(base_config.get());
ASSERT_EQ(AppListConfigType::kDense, base_config->type());
ASSERT_EQ(1, base_config->scale_x());
const int kMinGridWidth =
base_config->grid_tile_width() * kPreferredGridColumnsForWorkArea;
{
SCOPED_TRACE("Horizontal scaling");
// Reduce available width so the grid scales down horizontally.
const gfx::Size available_size(300, initial_available_size.height());
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 300.0f / kMinGridWidth);
}
{
SCOPED_TRACE("Vertical scaling");
// Reduce available height so the grid doesn't fit `preferred_rows` - the
// config should not be scaled, as apps grid is expected to reduce the
// number of visible rows in this case.
const gfx::Size available_size(initial_available_size.width(), 360);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 1);
}
{
SCOPED_TRACE("Horizontal and vertical scaling");
// Reduce both available width and height, and expect the grid to scale down
// horizontally only.
const gfx::Size available_size(300, 320);
std::unique_ptr<AppListConfig> config =
AppListConfigProvider::Get().CreateForTabletAppList(
work_area, kPreferredGridColumnsForWorkArea, available_size,
nullptr);
VerifyScaledConfig(*base_config, config.get(), 300.0f / kMinGridWidth);
}
}
} // namespace ash
Codebase Browser
chromium