1/*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <gtest/gtest.h>
18
19#include "avrcp_test_packets.h"
20#include "get_folder_items.h"
21#include "packet_test_helper.h"
22
23namespace bluetooth {
24namespace avrcp {
25
26using TestGetFolderItemsReqPacket = TestPacketType<GetFolderItemsRequest>;
27
28TEST(GetFolderItemsResponseBuilderTest, builderMediaPlayerSizeTest) {
29  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
30      Status::NO_ERROR, 0x0000, 0xFFFF);
31  // If there are no items, then the only data in the packet is the status
32  ASSERT_EQ(builder->size(), get_folder_items_error_response.size());
33
34  auto player = MediaPlayerItem(0x0001, "com.google.android.music", true);
35  builder->AddMediaPlayer(player);
36  ASSERT_EQ(builder->size(), get_folder_items_media_player_response.size());
37}
38
39TEST(GetFolderItemsResponseBuilderTest, builderMediaPlayerAddTest) {
40  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
41      Status::NO_ERROR, 0x0000, 0xFFFF);
42  auto player = MediaPlayerItem(0x0001, "com.google.android.music", true);
43  builder->AddMediaPlayer(player);
44
45  auto test_packet = TestGetFolderItemsReqPacket::Make();
46  builder->Serialize(test_packet);
47  ASSERT_EQ(test_packet->GetData(), get_folder_items_media_player_response);
48}
49
50TEST(GetFolderItemsResponseBuilderTest, builderPlayerAddMtuTest) {
51  MediaPlayerItem player1(1, "Player 1 that fits", true);
52  MediaPlayerItem player2(2, "Player 2 that doesn't fit", true);
53  MediaPlayerItem player3(3, "Player 3 that fits", true);
54
55  // Browsing Header + Status field + UID Counter field + Number of Items field
56  auto packet_size = BrowsePacket::kMinSize() + 5;
57  packet_size += player1.size() + player3.size();
58
59  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
60      Status::NO_ERROR, 0x0000, packet_size);
61
62  ASSERT_TRUE(builder->AddMediaPlayer(player1));
63  ASSERT_FALSE(builder->AddMediaPlayer(player2));
64  ASSERT_TRUE(builder->AddMediaPlayer(player3));
65}
66
67TEST(GetFolderItemsResponseBuilderTest, builderFolderSizeTest) {
68  auto builder = GetFolderItemsResponseBuilder::MakeVFSBuilder(Status::NO_ERROR,
69                                                               0x0000, 0xFFFF);
70  ASSERT_EQ(builder->size(), get_folder_items_error_response.size());
71
72  auto folder = FolderItem(0x0000000000000001, 0x00, true, "Test Folder");
73  builder->AddFolder(folder);
74  ASSERT_EQ(builder->size(), get_folder_items_folder_response.size());
75}
76
77TEST(GetFolderItemsResponseBuilderTest, builderFolderAddTest) {
78  auto builder = GetFolderItemsResponseBuilder::MakeVFSBuilder(Status::NO_ERROR,
79                                                               0x0000, 0xFFFF);
80  auto folder = FolderItem(0x0000000000000001, 0x00, true, "Test Folder");
81  builder->AddFolder(folder);
82
83  auto test_packet = TestGetFolderItemsReqPacket::Make();
84  builder->Serialize(test_packet);
85  ASSERT_EQ(test_packet->GetData(), get_folder_items_folder_response);
86}
87
88TEST(GetFolderItemsResponseBuilderTest, builderFolderAddMtuTest) {
89  FolderItem folder1(0x01, 0x00, true, "Folder 1 that fits");
90  FolderItem folder2(0x02, 0x00, true, "Folder 2 that doesn't fit");
91  FolderItem folder3(0x03, 0x00, true, "Folder 3 that fits");
92
93  // Browsing Header + Status field + UID Counter field + Number of Items field
94  auto packet_size = BrowsePacket::kMinSize() + 5;
95  packet_size += folder1.size() + folder3.size();
96
97  auto builder = GetFolderItemsResponseBuilder::MakeVFSBuilder(
98      Status::NO_ERROR, 0x0000, packet_size);
99
100  ASSERT_TRUE(builder->AddFolder(folder1));
101  ASSERT_FALSE(builder->AddFolder(folder2));
102  ASSERT_TRUE(builder->AddFolder(folder3));
103}
104
105TEST(GetFolderItemsResponseBuilderTest, builderSongSizeTest) {
106  auto builder = GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(
107      Status::NO_ERROR, 0x0000, 0xFFFF);
108  ASSERT_EQ(builder->size(), get_folder_items_error_response.size());
109
110  std::set<AttributeEntry> attributes;
111  attributes.insert(AttributeEntry(Attribute::TITLE, "Test Title"));
112  auto song = MediaElementItem(0x02, "Test Title", attributes);
113  builder->AddSong(song);
114  ASSERT_EQ(builder->size(), get_folder_items_song_response.size());
115}
116
117TEST(GetFolderItemsResponseBuilderTest, builderSongAddTest) {
118  auto builder = GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(
119      Status::NO_ERROR, 0x0000, 0xFFFF);
120  std::set<AttributeEntry> attributes;
121  attributes.insert(AttributeEntry(Attribute::TITLE, "Test Title"));
122  auto song = MediaElementItem(0x02, "Test Title", attributes);
123  builder->AddSong(song);
124
125  auto test_packet = TestGetFolderItemsReqPacket::Make();
126  builder->Serialize(test_packet);
127  ASSERT_EQ(test_packet->GetData(), get_folder_items_song_response);
128}
129
130TEST(GetFolderItemsResponseBuilderTest, builderSongAddMtuTest) {
131  MediaElementItem song1(0x01, "Song 1 that fits", std::set<AttributeEntry>());
132  MediaElementItem song2(0x02, "Song 2 that doesn't fit",
133                         std::set<AttributeEntry>());
134  MediaElementItem song3(0x03, "Song 3 that fits", std::set<AttributeEntry>());
135
136  auto packet_size = BrowsePacket::kMinSize() + 5;
137  packet_size += song1.size() + song3.size();
138
139  auto builder = GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(
140      Status::NO_ERROR, 0x0000, packet_size);
141
142  ASSERT_TRUE(builder->AddSong(song1));
143  ASSERT_FALSE(builder->AddSong(song2));
144  ASSERT_TRUE(builder->AddSong(song3));
145}
146
147TEST(GetFolderItemsResponseBuilderTest, builderNoItemsTest) {
148  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
149      Status::NO_ERROR, 0x0000, 0xFFFF);
150  auto test_packet = TestGetFolderItemsReqPacket::Make();
151  builder->Serialize(test_packet);
152  ASSERT_EQ(test_packet->GetData(), get_folder_items_error_response);
153
154  builder = GetFolderItemsResponseBuilder::MakeVFSBuilder(Status::NO_ERROR,
155                                                          0x0000, 0xFFFF);
156  test_packet = TestGetFolderItemsReqPacket::Make();
157  builder->Serialize(test_packet);
158  ASSERT_EQ(test_packet->GetData(), get_folder_items_error_response);
159
160  builder = GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(
161      Status::NO_ERROR, 0x0000, 0xFFFF);
162  test_packet = TestGetFolderItemsReqPacket::Make();
163  builder->Serialize(test_packet);
164  ASSERT_EQ(test_packet->GetData(), get_folder_items_error_response);
165}
166
167TEST(GetFolderItemsResponseBuilderTest, builderErrorStatusTest) {
168  std::vector<uint8_t> get_folder_items_inv_scope = {0x71, 0x00, 0x01, 0x0a};
169
170  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
171      Status::INVALID_SCOPE, 0x0000, 0xFFFF);
172
173  // Check that the status remains INVALID_SCOPE even though there are zero
174  // items
175  auto test_packet = TestGetFolderItemsReqPacket::Make();
176  builder->Serialize(test_packet);
177  ASSERT_EQ(test_packet->GetData(), get_folder_items_inv_scope);
178
179  auto player = MediaPlayerItem(0x0001, "com.google.android.music", true);
180  builder->AddMediaPlayer(player);
181
182  // Check to make sure that even though we added an item, it doesn't get
183  // written to the packet
184  test_packet = TestGetFolderItemsReqPacket::Make();
185  builder->Serialize(test_packet);
186  ASSERT_EQ(test_packet->GetData(), get_folder_items_inv_scope);
187}
188
189TEST(GetFolderItemsResponseBuilderTest, builderDeathTest) {
190  auto player = MediaPlayerItem(0x0001, "com.google.android.music", true);
191  auto folder = FolderItem(0x01, 0x00, true, "test folder");
192  auto song = MediaElementItem(0x01, "test song", std::set<AttributeEntry>());
193
194  auto builder = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
195      Status::NO_ERROR, 0x0000, 0xFFFF);
196  ASSERT_DEATH(builder->AddFolder(folder), "scope_ == Scope::VFS");
197  ASSERT_DEATH(builder->AddSong(song),
198               "scope_ == Scope::VFS \\|\\| scope_ == Scope::NOW_PLAYING");
199
200  builder = GetFolderItemsResponseBuilder::MakeVFSBuilder(Status::NO_ERROR,
201                                                          0x0000, 0xFFFF);
202  ASSERT_DEATH(builder->AddMediaPlayer(player),
203               "scope_ == Scope::MEDIA_PLAYER_LIST");
204
205  builder = GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(
206      Status::NO_ERROR, 0x0000, 0xFFFF);
207  ASSERT_DEATH(builder->AddMediaPlayer(player),
208               "scope_ == Scope::MEDIA_PLAYER_LIST");
209  ASSERT_DEATH(builder->AddFolder(folder), "scope_ == Scope::VFS");
210}
211
212TEST(GetFolderItemsRequestTest, getterTest) {
213  auto test_packet =
214      TestGetFolderItemsReqPacket::Make(get_folder_items_request_vfs);
215
216  ASSERT_EQ(test_packet->GetScope(), Scope::VFS);
217  ASSERT_EQ(test_packet->GetStartItem(), 0x00000000u);
218  ASSERT_EQ(test_packet->GetEndItem(), 0x00000005u);
219  ASSERT_EQ(test_packet->GetNumAttributes(), 1);
220
221  std::vector<Attribute> attribute_list = {Attribute::TITLE};
222  ASSERT_EQ(test_packet->GetAttributesRequested(), attribute_list);
223}
224
225TEST(GetFolderItemsRequestBuilderTest, builderZeroAttrsTest) {
226  auto builder =
227      GetFolderItemsRequestBuilder::MakeBuilder(Scope::VFS, 0, 9, {});
228  ASSERT_EQ(builder->size(), get_folder_items_request_no_attrs.size());
229
230  auto test_packet = TestGetFolderItemsReqPacket::Make();
231  builder->Serialize(test_packet);
232  ASSERT_EQ(test_packet->GetData(), get_folder_items_request_no_attrs);
233}
234
235TEST(GetFolderItemsRequestBuilderTest, builderTest) {
236  auto builder = GetFolderItemsRequestBuilder::MakeBuilder(Scope::VFS, 0, 9,
237                                                           {Attribute::TITLE});
238  ASSERT_EQ(builder->size(), get_folder_items_request_title.size());
239
240  auto test_packet = TestGetFolderItemsReqPacket::Make();
241  builder->Serialize(test_packet);
242  ASSERT_EQ(test_packet->GetData(), get_folder_items_request_title);
243}
244
245}  // namespace avrcp
246}  // namespace bluetooth