1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright 2014 The Chromium 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 "base/basictypes.h"
#include "base/bind.h"
#include "base/memory/scoped_ptr.h"
#include "chromecast/media/cma/ipc/media_memory_chunk.h"
#include "chromecast/media/cma/ipc/media_message.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chromecast {
namespace media {
namespace {
class ExternalMemoryBlock
: public MediaMemoryChunk {
public:
ExternalMemoryBlock(void* data, size_t size)
: data_(data), size_(size) {}
~ExternalMemoryBlock() override {}
// MediaMemoryChunk implementation.
void* data() const override { return data_; }
size_t size() const override { return size_; }
bool valid() const override { return true; }
private:
void* const data_;
const size_t size_;
};
scoped_ptr<MediaMemoryChunk> DummyAllocator(
void* data, size_t size, size_t alloc_size) {
CHECK_LE(alloc_size, size);
return scoped_ptr<MediaMemoryChunk>(
new ExternalMemoryBlock(data, alloc_size));
}
}
TEST(MediaMessageTest, WriteRead) {
int buffer_size = 1024;
scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
MediaMessage::MemoryAllocatorCB mem_alloc_cb(
base::Bind(&DummyAllocator, buffer.get(), buffer_size));
uint32 type = 0x1;
int msg_content_capacity = 512;
// Write a message.
int count = 64;
scoped_ptr<MediaMessage> msg1(
MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));
for (int k = 0; k < count; k++) {
int v1 = 2 * k + 1;
EXPECT_TRUE(msg1->WritePod(v1));
uint8 v2 = k;
EXPECT_TRUE(msg1->WritePod(v2));
}
EXPECT_EQ(msg1->content_size(), count * (sizeof(int) + sizeof(uint8)));
// Verify the integrity of the message.
scoped_ptr<MediaMessage> msg2(
MediaMessage::MapMessage(scoped_ptr<MediaMemoryChunk>(
new ExternalMemoryBlock(&buffer[0], buffer_size))));
for (int k = 0; k < count; k++) {
int v1;
int expected_v1 = 2 * k + 1;
EXPECT_TRUE(msg2->ReadPod(&v1));
EXPECT_EQ(v1, expected_v1);
uint8 v2;
uint8 expected_v2 = k;
EXPECT_TRUE(msg2->ReadPod(&v2));
EXPECT_EQ(v2, expected_v2);
}
}
TEST(MediaMessageTest, WriteOverflow) {
int buffer_size = 1024;
scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
MediaMessage::MemoryAllocatorCB mem_alloc_cb(
base::Bind(&DummyAllocator, buffer.get(), buffer_size));
uint32 type = 0x1;
int msg_content_capacity = 8;
scoped_ptr<MediaMessage> msg1(
MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));
uint32 v1 = 0;
uint8 v2 = 0;
EXPECT_TRUE(msg1->WritePod(v1));
EXPECT_TRUE(msg1->WritePod(v1));
EXPECT_FALSE(msg1->WritePod(v1));
EXPECT_FALSE(msg1->WritePod(v2));
}
TEST(MediaMessageTest, ReadOverflow) {
int buffer_size = 1024;
scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
MediaMessage::MemoryAllocatorCB mem_alloc_cb(
base::Bind(&DummyAllocator, buffer.get(), buffer_size));
uint32 type = 0x1;
int msg_content_capacity = 8;
scoped_ptr<MediaMessage> msg1(
MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));
uint32 v1 = 0xcd;
EXPECT_TRUE(msg1->WritePod(v1));
EXPECT_TRUE(msg1->WritePod(v1));
scoped_ptr<MediaMessage> msg2(
MediaMessage::MapMessage(scoped_ptr<MediaMemoryChunk>(
new ExternalMemoryBlock(&buffer[0], buffer_size))));
uint32 v2;
EXPECT_TRUE(msg2->ReadPod(&v2));
EXPECT_EQ(v2, v1);
EXPECT_TRUE(msg2->ReadPod(&v2));
EXPECT_EQ(v2, v1);
EXPECT_FALSE(msg2->ReadPod(&v2));
}
TEST(MediaMessageTest, DummyMessage) {
int buffer_size = 1024;
scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
MediaMessage::MemoryAllocatorCB mem_alloc_cb(
base::Bind(&DummyAllocator, buffer.get(), buffer_size));
uint32 type = 0x1;
// Create first a dummy message to estimate the content size.
scoped_ptr<MediaMessage> msg1(
MediaMessage::CreateDummyMessage(type));
uint32 v1 = 0xcd;
EXPECT_TRUE(msg1->WritePod(v1));
EXPECT_TRUE(msg1->WritePod(v1));
// Create the real message and write the actual content.
scoped_ptr<MediaMessage> msg2(
MediaMessage::CreateMessage(type, mem_alloc_cb, msg1->content_size()));
EXPECT_TRUE(msg2->WritePod(v1));
EXPECT_TRUE(msg2->WritePod(v1));
EXPECT_FALSE(msg2->WritePod(v1));
}
} // namespace media
} // namespace chromecast
|
