services/clipboard/clipboard_standalone_unittest.cc - Issue 768683003: Switch clipboard_unittests to clipboard_apptests.

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

Issue 768683003: Switch clipboard_unittests to clipboard_apptests. (Closed) Base URL: https://github.com/domokit/mojo.git@master

Patch Set: oneliners 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

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 "base/at_exit.h"

6 #include "base/bind.h"

7 #include "base/macros.h"

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

9 #include "mojo/services/public/interfaces/clipboard/clipboard.mojom.h"

10 #include "mojo/shell/shell_test_helper.h"

11 #include "testing/gtest/include/gtest/gtest.h"

12

13 namespace {

14

15 void CopyUint64AndEndRunloop(uint64_t* output,

16 base::RunLoop* run_loop,

17 uint64_t input) {

18 *output = input;

19 run_loop->Quit();

20 }

21

22 void CopyStringAndEndRunloop(std::string* output,

23 bool* string_is_null,

24 base::RunLoop* run_loop,

25 const mojo::Array<uint8_t>& input) {

26 *string_is_null = input.is_null();

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

28 run_loop->Quit();

29 }

30

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

32 base::RunLoop* run_loop,

33 const mojo::Array<mojo::String>& input) {

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

35 run_loop->Quit();

36 }

37

38 const char* kUninitialized = "Uninitialized data";

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

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

41

42 } // namespace

43

44 namespace mojo {

45 namespace service {

46

47 class ClipboardStandaloneTest : public testing::Test {

48 public:

49 ClipboardStandaloneTest() {}

50 ~ClipboardStandaloneTest() override {}

51

52 void SetUp() override {

53 test_helper_.Init();

54

55 test_helper_.application_manager()->ConnectToService(GURL("mojo:clipboard"),

56 &clipboard_);

57 }

58

59 uint64_t GetSequenceNumber() {

60 base::RunLoop run_loop;

61 uint64_t sequence_num = 999999;

62 clipboard_->GetSequenceNumber(

63 mojo::Clipboard::TYPE_COPY_PASTE,

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

65 run_loop.Run();

66 return sequence_num;

67 }

68

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

70 base::RunLoop run_loop;

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

72 types.push_back(kUninitialized);

73 clipboard_->GetAvailableMimeTypes(

74 mojo::Clipboard::TYPE_COPY_PASTE,

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

76 run_loop.Run();

77 return types;

78 }

79

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

81 base::RunLoop run_loop;

82 bool is_null = false;

83 clipboard_->ReadMimeType(

84 mojo::Clipboard::TYPE_COPY_PASTE,

85 mime_type,

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

87 run_loop.Run();

88 return !is_null;

89 }

90

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

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

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

94 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,

95 mime_data.Pass());

96 }

97

98 protected:

99 base::ShadowingAtExitManager at_exit_;

100 shell::ShellTestHelper test_helper_;

101

102 ClipboardPtr clipboard_;

103

104 DISALLOW_COPY_AND_ASSIGN(ClipboardStandaloneTest);

105 };

106

107 TEST_F(ClipboardStandaloneTest, EmptyClipboardOK) {

108 EXPECT_EQ(0ul, GetSequenceNumber());

109 EXPECT_TRUE(GetAvailableFormatMimeTypes().empty());

110 std::string data;

111 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

112 }

113

114 TEST_F(ClipboardStandaloneTest, CanReadBackText) {

115 std::string data;

116 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

117 EXPECT_EQ(0ul, GetSequenceNumber());

118

119 SetStringText(kPlainTextData);

120 EXPECT_EQ(1ul, GetSequenceNumber());

121

122 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

123 EXPECT_EQ(kPlainTextData, data);

124 }

125

126 TEST_F(ClipboardStandaloneTest, CanSetMultipleDataTypesAtOnce) {

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

128 mime_data[mojo::Clipboard::MIME_TYPE_TEXT] =

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

130 mime_data[mojo::Clipboard::MIME_TYPE_HTML] =

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

132

133 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,

134 mime_data.Pass());

135

136 EXPECT_EQ(1ul, GetSequenceNumber());

137

138 std::string data;

139 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

140 EXPECT_EQ(kPlainTextData, data);

141 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_HTML, &data));

142 EXPECT_EQ(kHtmlData, data);

143 }

144

145 TEST_F(ClipboardStandaloneTest, CanClearClipboardWithZeroArray) {

146 std::string data;

147 SetStringText(kPlainTextData);

148 EXPECT_EQ(1ul, GetSequenceNumber());

149

150 EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

151 EXPECT_EQ(kPlainTextData, data);

152

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

154 clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,

155 mime_data.Pass());

156

157 EXPECT_EQ(2ul, GetSequenceNumber());

158 EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));

159 }

160

161 } // namespace service

162 } // namespace mojo

OLD	NEW

« no previous file with comments | « services/clipboard/clipboard_apptest.cc ('k') | no next file » | no next file with comments »