components/clipboard/clipboard_apptest.cc - Issue 1685953002: mojo: Now that mandoline/ is deleted, also remove mojo:clipboard.

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

Issue 1685953002: mojo: Now that mandoline/ is deleted, also remove mojo:clipboard. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Fix android build. Created 4 years, 10 months 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

OLD	NEW
	(Empty)
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

3 // found in the LICENSE file.

4

5 #include <stdint.h>

6 #include <utility>

7

8 #include "base/bind.h"

9 #include "base/macros.h"

10 #include "base/run_loop.h"

11 #include "components/clipboard/public/interfaces/clipboard.mojom.h"

12 #include "mojo/common/common_type_converters.h"

13 #include "mojo/shell/public/cpp/application_test_base.h"

14 #include "mojo/shell/public/cpp/shell.h"

15

16 using mojo::Array;

17 using mojo::Clipboard;

18 using mojo::Map;

19 using mojo::String;

20

21 namespace {

22

23 void CopyUint64AndEndRunloop(uint64_t* output,

24 base::RunLoop* run_loop,

25 uint64_t input) {

26 *output = input;

27 run_loop->Quit();

28 }

29

30 void CopyStringAndEndRunloop(std::string* output,

31 bool* string_is_null,

32 base::RunLoop* run_loop,

33 const Array<uint8_t>& input) {

34 *string_is_null = input.is_null();

35 *output = input.is_null() ? "" : input.To<std::string>();

36 run_loop->Quit();

37 }

38

39 void CopyVectorStringAndEndRunloop(std::vector<std::string>* output,

40 base::RunLoop* run_loop,

41 const Array<String>& input) {

42 *output = input.To<std::vector<std::string> >();

43 run_loop->Quit();

44 }

45

46 const char* kUninitialized = "Uninitialized data";

47 const char* kPlainTextData = "Some plain data";

48 const char* kHtmlData = "<html>data</html>";

49

50 } // namespace

51

52 namespace clipboard {

53

54 class ClipboardAppTest : public mojo::test::ApplicationTestBase {

55 public:

56 ClipboardAppTest() : ApplicationTestBase() {}

57 ~ClipboardAppTest() override {}

58

59 void SetUp() override {

60 mojo::test::ApplicationTestBase::SetUp();

61 shell()->ConnectToService("mojo:clipboard", &clipboard_);

62 }

63

64 uint64_t GetSequenceNumber() {

65 base::RunLoop run_loop;

66 uint64_t sequence_num = 999999;

67 clipboard_->GetSequenceNumber(

68 Clipboard::Type::COPY_PASTE,

69 base::Bind(&CopyUint64AndEndRunloop, &sequence_num, &run_loop));

70 run_loop.Run();

71 return sequence_num;

72 }

73

74 std::vector<std::string> GetAvailableFormatMimeTypes() {

75 base::RunLoop run_loop;

76 std::vector<std::string> types;

77 types.push_back(kUninitialized);

78 clipboard_->GetAvailableMimeTypes(

79 Clipboard::Type::COPY_PASTE,

80 base::Bind(&CopyVectorStringAndEndRunloop, &types, &run_loop));

81 run_loop.Run();

82 return types;

83 }

84

85 bool GetDataOfType(const std::string& mime_type, std::string* data) {

86 base::RunLoop run_loop;

87 bool is_null = false;

88 clipboard_->ReadMimeType(

89 Clipboard::Type::COPY_PASTE, mime_type,

90 base::Bind(&CopyStringAndEndRunloop, data, &is_null, &run_loop));

91 run_loop.Run();

92 return !is_null;

93 }

94

95 void SetStringText(const std::string& data) {

96 Map<String, Array<uint8_t>> mime_data;

97 mime_data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data);

98 clipboard_->WriteClipboardData(Clipboard::Type::COPY_PASTE,

99 std::move(mime_data));

100 }

101

102 protected:

103 mojo::ClipboardPtr clipboard_;

104

105 DISALLOW_COPY_AND_ASSIGN(ClipboardAppTest);

106 };

107

108 TEST_F(ClipboardAppTest, EmptyClipboardOK) {

109 EXPECT_EQ(0ul, GetSequenceNumber());

110 EXPECT_TRUE(GetAvailableFormatMimeTypes().empty());

111 std::string data;

112 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

113 }

114

115 TEST_F(ClipboardAppTest, CanReadBackText) {

116 std::string data;

117 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

118 EXPECT_EQ(0ul, GetSequenceNumber());

119

120 SetStringText(kPlainTextData);

121 EXPECT_EQ(1ul, GetSequenceNumber());

122

123 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

124 EXPECT_EQ(kPlainTextData, data);

125 }

126

127 TEST_F(ClipboardAppTest, CanSetMultipleDataTypesAtOnce) {

128 Map<String, Array<uint8_t>> mime_data;

129 mime_data[Clipboard::MIME_TYPE_TEXT] =

130 Array<uint8_t>::From(std::string(kPlainTextData));

131 mime_data[Clipboard::MIME_TYPE_HTML] =

132 Array<uint8_t>::From(std::string(kHtmlData));

133

134 clipboard_->WriteClipboardData(Clipboard::Type::COPY_PASTE,

135 std::move(mime_data));

136

137 EXPECT_EQ(1ul, GetSequenceNumber());

138

139 std::string data;

140 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

141 EXPECT_EQ(kPlainTextData, data);

142 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_HTML, &data));

143 EXPECT_EQ(kHtmlData, data);

144 }

145

146 TEST_F(ClipboardAppTest, CanClearClipboardWithZeroArray) {

147 std::string data;

148 SetStringText(kPlainTextData);

149 EXPECT_EQ(1ul, GetSequenceNumber());

150

151 EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

152 EXPECT_EQ(kPlainTextData, data);

153

154 Map<String, Array<uint8_t>> mime_data;

155 clipboard_->WriteClipboardData(Clipboard::Type::COPY_PASTE,

156 std::move(mime_data));

157

158 EXPECT_EQ(2ul, GetSequenceNumber());

159 EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));

160 }

161

162 } // namespace clipboard

OLD	NEW

« no previous file with comments | « components/clipboard/clipboard_application_delegate.cc ('k') | components/clipboard/clipboard_standalone_impl.h » ('j') | no next file with comments »