Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(93)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: services/clipboard/clipboard_apptest.cc

Issue 779063003: Move //services/clipboard code out of namespace mojo (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « services/clipboard/BUILD.gn ('k') | services/clipboard/clipboard_standalone_impl.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/bind.h" 5 #include "base/bind.h"
6 #include "base/run_loop.h" 6 #include "base/run_loop.h"
7 #include "mojo/common/common_type_converters.h" 7 #include "mojo/common/common_type_converters.h"
8 #include "mojo/public/cpp/application/application_impl.h" 8 #include "mojo/public/cpp/application/application_impl.h"
9 #include "mojo/public/cpp/application/application_test_base.h" 9 #include "mojo/public/cpp/application/application_test_base.h"
10 #include "mojo/services/public/interfaces/clipboard/clipboard.mojom.h" 10 #include "mojo/services/public/interfaces/clipboard/clipboard.mojom.h"
(...skipping 22 matching lines...) Expand all
33 *output = input.To<std::vector<std::string> >(); 33 *output = input.To<std::vector<std::string> >();
34 run_loop->Quit(); 34 run_loop->Quit();
35 } 35 }
36 36
37 const char* kUninitialized = "Uninitialized data"; 37 const char* kUninitialized = "Uninitialized data";
38 const char* kPlainTextData = "Some plain data"; 38 const char* kPlainTextData = "Some plain data";
39 const char* kHtmlData = "<html>data</html>"; 39 const char* kHtmlData = "<html>data</html>";
40 40
41 } // namespace 41 } // namespace
42 42
43 namespace mojo { 43 using mojo::Array;
44 using mojo::Clipboard;
45 using mojo::Map;
46 using mojo::String;
Elliot Glaysher 2014/12/04 23:16:27 This should be above the anonymous namespace. (And
47
44 namespace service { 48 namespace service {
45 49
46 class ClipboardAppTest : public test::ApplicationTestBase { 50 class ClipboardAppTest : public mojo::test::ApplicationTestBase {
47 public: 51 public:
48 ClipboardAppTest() : ApplicationTestBase() {} 52 ClipboardAppTest() : ApplicationTestBase() {}
49 ~ClipboardAppTest() override {} 53 ~ClipboardAppTest() override {}
50 54
51 void SetUp() override { 55 void SetUp() override {
52 ApplicationTestBase::SetUp(); 56 mojo::test::ApplicationTestBase::SetUp();
53 application_impl()->ConnectToService("mojo:clipboard", &clipboard_); 57 application_impl()->ConnectToService("mojo:clipboard", &clipboard_);
54 } 58 }
55 59
56 uint64_t GetSequenceNumber() { 60 uint64_t GetSequenceNumber() {
57 base::RunLoop run_loop; 61 base::RunLoop run_loop;
58 uint64_t sequence_num = 999999; 62 uint64_t sequence_num = 999999;
59 clipboard_->GetSequenceNumber( 63 clipboard_->GetSequenceNumber(
60 mojo::Clipboard::TYPE_COPY_PASTE, 64 Clipboard::TYPE_COPY_PASTE,
61 base::Bind(&CopyUint64AndEndRunloop, &sequence_num, &run_loop)); 65 base::Bind(&CopyUint64AndEndRunloop, &sequence_num, &run_loop));
62 run_loop.Run(); 66 run_loop.Run();
63 return sequence_num; 67 return sequence_num;
64 } 68 }
65 69
66 std::vector<std::string> GetAvailableFormatMimeTypes() { 70 std::vector<std::string> GetAvailableFormatMimeTypes() {
67 base::RunLoop run_loop; 71 base::RunLoop run_loop;
68 std::vector<std::string> types; 72 std::vector<std::string> types;
69 types.push_back(kUninitialized); 73 types.push_back(kUninitialized);
70 clipboard_->GetAvailableMimeTypes( 74 clipboard_->GetAvailableMimeTypes(
71 mojo::Clipboard::TYPE_COPY_PASTE, 75 Clipboard::TYPE_COPY_PASTE,
72 base::Bind(&CopyVectorStringAndEndRunloop, &types, &run_loop)); 76 base::Bind(&CopyVectorStringAndEndRunloop, &types, &run_loop));
73 run_loop.Run(); 77 run_loop.Run();
74 return types; 78 return types;
75 } 79 }
76 80
77 bool GetDataOfType(const std::string& mime_type, std::string* data) { 81 bool GetDataOfType(const std::string& mime_type, std::string* data) {
78 base::RunLoop run_loop; 82 base::RunLoop run_loop;
79 bool is_null = false; 83 bool is_null = false;
80 clipboard_->ReadMimeType( 84 clipboard_->ReadMimeType(
81 mojo::Clipboard::TYPE_COPY_PASTE, 85 Clipboard::TYPE_COPY_PASTE,
82 mime_type, 86 mime_type,
83 base::Bind(&CopyStringAndEndRunloop, data, &is_null, &run_loop)); 87 base::Bind(&CopyStringAndEndRunloop, data, &is_null, &run_loop));
84 run_loop.Run(); 88 run_loop.Run();
85 return !is_null; 89 return !is_null;
86 } 90 }
87 91
88 void SetStringText(const std::string& data) { 92 void SetStringText(const std::string& data) {
89 Map<String, Array<uint8_t>> mime_data; 93 Map<String, Array<uint8_t>> mime_data;
90 mime_data[mojo::Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data); 94 mime_data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data);
91 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE, 95 clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE,
92 mime_data.Pass()); 96 mime_data.Pass());
93 } 97 }
94 98
95 protected: 99 protected:
96 ClipboardPtr clipboard_; 100 mojo::ClipboardPtr clipboard_;
97 101
98 DISALLOW_COPY_AND_ASSIGN(ClipboardAppTest); 102 DISALLOW_COPY_AND_ASSIGN(ClipboardAppTest);
99 }; 103 };
100 104
101 TEST_F(ClipboardAppTest, EmptyClipboardOK) { 105 TEST_F(ClipboardAppTest, EmptyClipboardOK) {
102 EXPECT_EQ(0ul, GetSequenceNumber()); 106 EXPECT_EQ(0ul, GetSequenceNumber());
103 EXPECT_TRUE(GetAvailableFormatMimeTypes().empty()); 107 EXPECT_TRUE(GetAvailableFormatMimeTypes().empty());
104 std::string data; 108 std::string data;
105 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 109 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
106 } 110 }
107 111
108 TEST_F(ClipboardAppTest, CanReadBackText) { 112 TEST_F(ClipboardAppTest, CanReadBackText) {
109 std::string data; 113 std::string data;
110 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 114 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
111 EXPECT_EQ(0ul, GetSequenceNumber()); 115 EXPECT_EQ(0ul, GetSequenceNumber());
112 116
113 SetStringText(kPlainTextData); 117 SetStringText(kPlainTextData);
114 EXPECT_EQ(1ul, GetSequenceNumber()); 118 EXPECT_EQ(1ul, GetSequenceNumber());
115 119
116 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 120 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
117 EXPECT_EQ(kPlainTextData, data); 121 EXPECT_EQ(kPlainTextData, data);
118 } 122 }
119 123
120 TEST_F(ClipboardAppTest, CanSetMultipleDataTypesAtOnce) { 124 TEST_F(ClipboardAppTest, CanSetMultipleDataTypesAtOnce) {
121 Map<String, Array<uint8_t>> mime_data; 125 Map<String, Array<uint8_t>> mime_data;
122 mime_data[mojo::Clipboard::MIME_TYPE_TEXT] = 126 mime_data[Clipboard::MIME_TYPE_TEXT] =
123 Array<uint8_t>::From(std::string(kPlainTextData)); 127 Array<uint8_t>::From(std::string(kPlainTextData));
124 mime_data[mojo::Clipboard::MIME_TYPE_HTML] = 128 mime_data[Clipboard::MIME_TYPE_HTML] =
125 Array<uint8_t>::From(std::string(kHtmlData)); 129 Array<uint8_t>::From(std::string(kHtmlData));
126 130
127 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE, 131 clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE,
128 mime_data.Pass()); 132 mime_data.Pass());
129 133
130 EXPECT_EQ(1ul, GetSequenceNumber()); 134 EXPECT_EQ(1ul, GetSequenceNumber());
131 135
132 std::string data; 136 std::string data;
133 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 137 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
134 EXPECT_EQ(kPlainTextData, data); 138 EXPECT_EQ(kPlainTextData, data);
135 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_HTML, &data)); 139 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_HTML, &data));
136 EXPECT_EQ(kHtmlData, data); 140 EXPECT_EQ(kHtmlData, data);
137 } 141 }
138 142
139 TEST_F(ClipboardAppTest, CanClearClipboardWithZeroArray) { 143 TEST_F(ClipboardAppTest, CanClearClipboardWithZeroArray) {
140 std::string data; 144 std::string data;
141 SetStringText(kPlainTextData); 145 SetStringText(kPlainTextData);
142 EXPECT_EQ(1ul, GetSequenceNumber()); 146 EXPECT_EQ(1ul, GetSequenceNumber());
143 147
144 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 148 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
145 EXPECT_EQ(kPlainTextData, data); 149 EXPECT_EQ(kPlainTextData, data);
146 150
147 Map<String, Array<uint8_t>> mime_data; 151 Map<String, Array<uint8_t>> mime_data;
148 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE, 152 clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE,
149 mime_data.Pass()); 153 mime_data.Pass());
150 154
151 EXPECT_EQ(2ul, GetSequenceNumber()); 155 EXPECT_EQ(2ul, GetSequenceNumber());
152 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data)); 156 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
153 } 157 }
154 158
155 } // namespace service 159 } // namespace service
156 } // namespace mojo
OLDNEW
« no previous file with comments | « services/clipboard/BUILD.gn ('k') | services/clipboard/clipboard_standalone_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698