| // Copyright 2018 The Chromium OS 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 <map> |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/environment.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <gtest/gtest.h> |
| |
| #include "vm_tools/garcon/desktop_file.h" |
| |
| namespace vm_tools { |
| namespace garcon { |
| |
| namespace { |
| struct DesktopFileTestData { |
| std::string app_id; |
| std::string entry_type; |
| std::map<std::string, std::string> locale_name_map; |
| std::map<std::string, std::string> locale_comment_map; |
| std::map<std::string, std::vector<std::string>> locale_keywords_map; |
| bool no_display; |
| std::string icon; |
| bool hidden; |
| std::vector<std::string> only_show_in; |
| std::string try_exec; |
| std::string exec; |
| std::string path; |
| bool terminal; |
| std::vector<std::string> mime_types; |
| std::vector<std::string> categories; |
| std::string startup_wm_class; |
| bool startup_notify; |
| }; |
| |
| constexpr char kFilename1[] = "/absolute/file/path"; |
| constexpr char kFilename2[] = "file_path"; |
| constexpr char kUrl1[] = "http://www.example.com/"; |
| constexpr char kUrl2[] = "http://www.example.com.fr/foo/"; |
| |
| class DesktopFileTest : public ::testing::Test { |
| public: |
| DesktopFileTest() { |
| CHECK(temp_dir_.CreateUniqueTempDir()); |
| apps_dir_ = temp_dir_.GetPath().Append("applications"); |
| CHECK(base::CreateDirectory(apps_dir_)); |
| // Set the XDG_DATA_DIRS env var to be the one we created as our |
| // temp dir. Also add a 'path' subdir which we will add to the system |
| // path env var. |
| std::unique_ptr<base::Environment> env = base::Environment::Create(); |
| env->SetVar("XDG_DATA_DIRS", temp_dir_.GetPath().value()); |
| base::FilePath sys_path = temp_dir_.GetPath().Append("path"); |
| CHECK(base::CreateDirectory(sys_path)); |
| std::string curr_path; |
| CHECK(env->GetVar("PATH", &curr_path)); |
| env->SetVar("PATH", curr_path + ":" + sys_path.value()); |
| } |
| DesktopFileTest(const DesktopFileTest&) = delete; |
| DesktopFileTest& operator=(const DesktopFileTest&) = delete; |
| |
| ~DesktopFileTest() override = default; |
| |
| base::FilePath WriteContentsToPath(const std::string& file_contents, |
| const std::string& relative_path) { |
| base::FilePath desktop_file_path = apps_dir_.Append(relative_path); |
| // If there's a relative path, create any directories in it. |
| CHECK(base::CreateDirectory(desktop_file_path.DirName())); |
| EXPECT_EQ(file_contents.size(), |
| base::WriteFile(desktop_file_path, file_contents.c_str(), |
| file_contents.size())); |
| return desktop_file_path; |
| } |
| |
| std::unique_ptr<DesktopFile> ValidateDesktopFile( |
| const std::string& file_contents, |
| const std::string& relative_path, |
| const DesktopFileTestData& results, |
| bool expect_pass) { |
| base::FilePath desktop_file_path = |
| WriteContentsToPath(file_contents, relative_path); |
| std::unique_ptr<DesktopFile> result = |
| DesktopFile::ParseDesktopFile(desktop_file_path); |
| if (!expect_pass) { |
| EXPECT_EQ(nullptr, result.get()); |
| return nullptr; |
| } |
| EXPECT_EQ(result->app_id(), results.app_id); |
| EXPECT_EQ(result->entry_type(), results.entry_type); |
| EXPECT_EQ(result->locale_name_map(), results.locale_name_map); |
| EXPECT_EQ(result->locale_comment_map(), results.locale_comment_map); |
| EXPECT_EQ(result->locale_keywords_map(), results.locale_keywords_map); |
| EXPECT_EQ(result->no_display(), results.no_display); |
| EXPECT_EQ(result->icon(), results.icon); |
| EXPECT_EQ(result->hidden(), results.hidden); |
| EXPECT_EQ(result->only_show_in(), results.only_show_in); |
| EXPECT_EQ(result->try_exec(), results.try_exec); |
| EXPECT_EQ(result->exec(), results.exec); |
| EXPECT_EQ(result->path(), results.path); |
| EXPECT_EQ(result->terminal(), results.terminal); |
| EXPECT_EQ(result->mime_types(), results.mime_types); |
| EXPECT_EQ(result->categories(), results.categories); |
| EXPECT_EQ(result->startup_wm_class(), results.startup_wm_class); |
| EXPECT_EQ(result->startup_notify(), results.startup_notify); |
| return result; |
| } |
| |
| void ValidateExecutableFileName( |
| const std::string& file_contents, |
| const std::string& relative_path, |
| const std::string& expect_executable_file_name) { |
| base::FilePath desktop_file_path = |
| WriteContentsToPath(file_contents, relative_path); |
| std::unique_ptr<DesktopFile> result = |
| DesktopFile::ParseDesktopFile(desktop_file_path); |
| EXPECT_EQ(result->GenerateExecutableFileName(), |
| expect_executable_file_name); |
| } |
| |
| bool ShouldPassDesktopFileContents(const std::string& file_contents, |
| const std::string& relative_path) { |
| base::FilePath test_path = |
| WriteContentsToPath(file_contents, relative_path); |
| std::unique_ptr<DesktopFile> desktop_file = |
| DesktopFile::ParseDesktopFile(test_path); |
| EXPECT_NE(nullptr, desktop_file.get()); |
| return desktop_file->ShouldPassToHost(); |
| } |
| |
| private: |
| base::ScopedTempDir temp_dir_; |
| base::FilePath apps_dir_; |
| }; |
| |
| } // namespace |
| |
| // This tests most parsing, comments, line breaks, multi-strings, simple |
| // locales and that all the keys we care about are parsed and invalid ones are |
| // ignored. |
| TEST_F(DesktopFileTest, AllKeys) { |
| ValidateDesktopFile( |
| "#Comment1\n" |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Test\n" |
| "\n\n" |
| "Name[fr]=Test French\n" |
| "Comment=Test me out!\n" |
| "Comment[es]=Hola for the comment\n" |
| "#Comment2\n" |
| "#Comment3\n" |
| "Keywords=english;key;word\n" |
| "Keywords[fr]=french;ki;ward\n" |
| "NoDisplay=true\n" |
| "Icon=prettyicon\n" |
| "Hidden=true\n" |
| "\n\n" |
| "OnlyShowIn=KDE;Gnome;\n" |
| "TryExec=mybinary\n" |
| "UnknownKey=trickster\n" |
| "Exec=mybinary %F\n" |
| "#Comment4\n" |
| "Path=/usr/local/bin\n" |
| "Terminal=true\n" |
| "MimeType=text/plain;foo/x-java\n" |
| "Categories=Magic;Playtime\n" |
| "StartupWMClass=classy\n" |
| "StartupNotify=true\n", |
| "test.desktop", |
| { |
| "test", |
| "Application", |
| {std::make_pair("", "Test"), std::make_pair("fr", "Test French")}, |
| {std::make_pair("", "Test me out!"), |
| std::make_pair("es", "Hola for the comment")}, |
| { |
| std::pair<std::string, std::vector<std::string>>( |
| "", {"english", "key", "word"}), |
| std::pair<std::string, std::vector<std::string>>( |
| "fr", {"french", "ki", "ward"}), |
| }, |
| true, |
| "prettyicon", |
| true, |
| {"KDE", "Gnome"}, |
| "mybinary", |
| "mybinary %F", |
| "/usr/local/bin", |
| true, |
| {"text/plain", "foo/x-java"}, |
| {"Magic", "Playtime"}, |
| "classy", |
| true, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, Locales) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=LocaleTest\n" |
| "Name[sr]=Test sr foo\n" |
| "Name[sr_YU]=Test sr underscore YU foo\n" |
| "Name[sr_YU@Latn]=Test sr underscore YU at Latn foo\n" |
| "Name[sr@Latn]=Test sr at Latn foo\n" |
| "Name[ab]=Test ab foo\n" |
| "Name[ab_cd]=Test ab underscore cd foo\n" |
| "Name[ab_cd@xyz]=Test ab underscore cd at xyz foo\n" |
| "Name[ab@xyz]=Test ab at xyz foo\n", |
| "locales.desktop", |
| { |
| "locales", |
| "Application", |
| { |
| std::make_pair("", "LocaleTest"), |
| std::make_pair("sr", "Test sr foo"), |
| std::make_pair("sr_YU", "Test sr underscore YU foo"), |
| std::make_pair("sr_YU@Latn", "Test sr underscore YU at Latn foo"), |
| std::make_pair("sr@Latn", "Test sr at Latn foo"), |
| std::make_pair("ab", "Test ab foo"), |
| std::make_pair("ab_cd", "Test ab underscore cd foo"), |
| std::make_pair("ab_cd@xyz", "Test ab underscore cd at xyz foo"), |
| std::make_pair("ab@xyz", "Test ab at xyz foo"), |
| }, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, Escaping) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Test \\\"Quoted\\\" \\t tab \\s space \\r CR \\n newline \\\\ " |
| "backslash\n" |
| "OnlyShowIn=semicolon\\;;;AfterEmpty;Another\\;Semi;\n", |
| "EscapeMe.desktop", |
| { |
| "EscapeMe", |
| "Application", |
| { |
| std::make_pair("", |
| "Test \"Quoted\" \t tab space \r CR \n newline " |
| "\\ backslash"), |
| }, |
| {}, |
| {}, |
| false, |
| "", |
| false, |
| {"semicolon;", "", "AfterEmpty", "Another;Semi"}, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, WhitespaceRemoval) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type =Application \n" |
| "Name = TestW\n", |
| "whitespace.desktop", |
| { |
| "whitespace", |
| "Application", |
| {std::make_pair("", "TestW")}, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, Types) { |
| EXPECT_TRUE(ValidateDesktopFile("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "ApplicationTest.desktop", |
| { |
| "ApplicationTest", |
| "Application", |
| {std::make_pair("", "TestApplication")}, |
| }, |
| true) |
| ->IsApplication()); |
| EXPECT_FALSE(ValidateDesktopFile("[Desktop Entry]\n" |
| "Type=Directory\n" |
| "Name=TestDirectory\n", |
| "DirectoryTest.desktop", |
| { |
| "DirectoryTest", |
| "Directory", |
| {std::make_pair("", "TestDirectory")}, |
| }, |
| true) |
| ->IsApplication()); |
| EXPECT_FALSE(ValidateDesktopFile("[Desktop Entry]\n" |
| "Type=Link\n" |
| "Name=TestLink\n", |
| "LinkTest.desktop", |
| { |
| "LinkTest", |
| "Link", |
| {std::make_pair("", "TestLink")}, |
| }, |
| true) |
| ->IsApplication()); |
| // Now try an invalid type, which should fail |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=FakeType\n" |
| "Name=TestLink\n", |
| "faketype.desktop", {}, false); |
| } |
| |
| TEST_F(DesktopFileTest, RelativePathConversion) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Test\n", |
| "foo/bar_fun/mad.desktop", |
| { |
| "foo-bar_fun-mad", |
| "Application", |
| {std::make_pair("", "Test")}, |
| }, |
| true); |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Test\n", |
| "foo/applications/bar.desktop", |
| { |
| "foo-applications-bar", |
| "Application", |
| {std::make_pair("", "Test")}, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, IgnoreOtherGroups) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n" |
| "[Desktop Action Foo]\n" |
| "Type=Directory\n" |
| "Name=BadApplication\n", |
| "ApplicationTest.desktop", |
| { |
| "ApplicationTest", |
| "Application", |
| {std::make_pair("", "TestApplication")}, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, FindDesktopFile) { |
| base::FilePath test_path = WriteContentsToPath( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "FindTest.desktop"); |
| EXPECT_EQ(test_path.value(), |
| DesktopFile::FindFileForDesktopId("FindTest").value()); |
| test_path = WriteContentsToPath( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "find/me/in/subdir.desktop"); |
| EXPECT_EQ(test_path.value(), |
| DesktopFile::FindFileForDesktopId("find-me-in-subdir").value()); |
| test_path = WriteContentsToPath( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "test/applications/subdir.desktop"); |
| EXPECT_EQ( |
| test_path.value(), |
| DesktopFile::FindFileForDesktopId("test-applications-subdir").value()); |
| test_path = WriteContentsToPath( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "dashes-in-name.desktop"); |
| EXPECT_EQ(test_path.value(), |
| DesktopFile::FindFileForDesktopId("dashes-in-name").value()); |
| } |
| |
| TEST_F(DesktopFileTest, GenerateArgvNoArgs) { |
| EXPECT_EQ(ValidateDesktopFile("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Vim\n" |
| "Exec=/usr/bin/vim\n", |
| "vim.desktop", |
| { |
| "vim", |
| "Application", |
| {std::make_pair("", "Vim")}, |
| {}, |
| {}, |
| false, |
| "", |
| false, |
| {}, |
| "", |
| "/usr/bin/vim", |
| }, |
| true) |
| ->GenerateArgvWithFiles(std::vector<std::string>()), |
| std::vector<std::string>({"/usr/bin/vim"})); |
| } |
| |
| TEST_F(DesktopFileTest, GenerateArgvComplexArgs) { |
| std::unique_ptr<DesktopFile> desktop_file = ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Foobar\n" |
| "Icon=fooicon\n" |
| "Exec=foobar.bin --singlefile=%f MultiFile %F --single_url %u " |
| "multi-url %U Icon %i Name %c DesktopPath %k\n", |
| "foobar.desktop", |
| { |
| "foobar", |
| "Application", |
| {std::make_pair("", "Foobar")}, |
| {}, |
| {}, |
| false, |
| "fooicon", |
| false, |
| {}, |
| "", |
| "foobar.bin --singlefile=%f MultiFile %F --single_url %u " |
| "multi-url %U Icon %i Name %c DesktopPath %k", |
| }, |
| true); |
| EXPECT_EQ(desktop_file->GenerateArgvWithFiles(std::vector<std::string>( |
| {kFilename1, kFilename2, kUrl1, kUrl2})), |
| std::vector<std::string>({ |
| "foobar.bin", |
| std::string("--singlefile=").append(kFilename1), |
| "MultiFile", |
| kFilename1, |
| kFilename2, |
| kUrl1, |
| kUrl2, |
| "--single_url", |
| kFilename1, |
| "multi-url", |
| kFilename1, |
| kFilename2, |
| kUrl1, |
| kUrl2, |
| "Icon", |
| "--icon", |
| "fooicon", |
| "Name", |
| "Foobar", |
| "DesktopPath", |
| desktop_file->file_path().value(), |
| })); |
| } |
| |
| TEST_F(DesktopFileTest, GenerateArgvWithQuotingAndEscaping) { |
| EXPECT_EQ(ValidateDesktopFile( |
| u8R"xxx( |
| [Desktop Entry] |
| Type=Application |
| Name=QuoteMaster |
| Exec=quote-master %% \"A B %f %i C \\" B \\\\ \" \"C D\" |
| )xxx", |
| "quoter.desktop", |
| { |
| "quoter", |
| "Application", |
| {std::make_pair("", "QuoteMaster")}, |
| {}, |
| {}, |
| false, |
| "", |
| false, |
| {}, |
| "", |
| u8R"xxx(quote-master %% "A B %f %i C \" B \\ " "C D")xxx", |
| }, |
| true) |
| ->GenerateArgvWithFiles(std::vector<std::string>()), |
| std::vector<std::string>( |
| {"quote-master", "%", u8R"xxx(A B %f %i C " B \ )xxx", "C D"})); |
| } |
| |
| TEST_F(DesktopFileTest, MissingNameFails) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name[fr]=AlsoNeedNoLocaleName\n", |
| "MissingName.desktop", {}, false); |
| } |
| |
| TEST_F(DesktopFileTest, InvalidFileExtensionFails) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestName\n", |
| "badextension.notdesktop", {}, false); |
| } |
| |
| TEST_F(DesktopFileTest, PassDesktopFileBasic) { |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, DontPassNonApplicationDesktopFiles) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Link\n" |
| "Exec=mybinary\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Directory\n" |
| "Exec=mybinary\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, PassCheckHiddenDesktopFiles) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Hidden=true\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Hidden=false\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, DontPassDesktopFileWithoutExec) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, PassCheckNoDisplayDesktopFiles) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "NoDisplay=true\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "NoDisplay=true\n" |
| "MimeType=text/plain\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "NoDisplay=false\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, DontPassDesktopFileWithOnlyShowIn) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "OnlyShowIn=KDE\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, PassCheckTerminalDesktopFiles) { |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Terminal=true\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Terminal=false\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, PassCheckCategoriesDesktopFiles) { |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Categories=Internet\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=mybinary\n" |
| "Categories=Settings\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, PassCheckTryExecDesktopFiles) { |
| // If TryExec is there, the path must exist and have the executable bit set. |
| base::FilePath fake_exec = |
| WriteContentsToPath("#/bin/sh\necho foo", "../path/fakebinary.sh"); |
| EXPECT_FALSE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=fakebinary.sh\n" |
| "TryExec=" + |
| fake_exec.value() + |
| "\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| EXPECT_TRUE(base::SetPosixFilePermissions( |
| fake_exec, base::FILE_PERMISSION_READ_BY_USER | |
| base::FILE_PERMISSION_EXECUTE_BY_USER)); |
| // Absolute path. |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=fakebinary.sh\n" |
| "TryExec=" + |
| fake_exec.value() + |
| "\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| // System path. |
| EXPECT_TRUE( |
| ShouldPassDesktopFileContents("[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=fakebinary.sh\n" |
| "TryExec=fakebinary.sh\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop")); |
| } |
| |
| TEST_F(DesktopFileTest, Keywords) { |
| ValidateDesktopFile( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=Keywords\n" |
| "Keywords[ab]=nice;test\n" |
| "Keywords[bc]=okay;trial\n" |
| "Keywords[de]=poor;mock\n" |
| "Keywords[fg]=moderate;copy\n", |
| "keywords.desktop", |
| { |
| "keywords", |
| "Application", |
| {std::make_pair("", "Keywords")}, |
| {}, |
| { |
| std::pair<std::string, std::vector<std::string>>( |
| "ab", {"nice", "test"}), |
| std::pair<std::string, std::vector<std::string>>( |
| "bc", {"okay", "trial"}), |
| std::pair<std::string, std::vector<std::string>>( |
| "de", {"poor", "mock"}), |
| std::pair<std::string, std::vector<std::string>>( |
| "fg", {"moderate", "copy"}), |
| }, |
| }, |
| true); |
| } |
| |
| TEST_F(DesktopFileTest, ExecName) { |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=myExe\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", "myExe"); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=my/excellent/path/myExe\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", "myExe"); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=my/excellent/path/myExe -arg1 arg\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", "myExe"); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=my/excellent/path/e\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", "e"); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=my/excellent/path/\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", "path"); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Exec=\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", ""); |
| ValidateExecutableFileName( |
| "[Desktop Entry]\n" |
| "Type=Application\n" |
| "Name=TestApplication\n", |
| "FilterTest.desktop", ""); |
| } |
| |
| } // namespace garcon |
| } // namespace vm_tools |
