16
16
using namespace ::testing;
17
17
using ::executorch::aten::ScalarType;
18
18
using ::executorch::aten::Tensor;
19
+ using ::executorch::etdump::BufferDataSink;
19
20
using ::executorch::runtime::Error;
20
21
using ::executorch::runtime::Result;
21
22
using ::executorch::runtime::Span;
@@ -29,7 +30,11 @@ class BufferDataSinkTest : public ::testing::Test {
29
30
buffer_size_ = 128 ; // Small size for testing
30
31
buffer_ptr_ = malloc (buffer_size_);
31
32
buffer_ = Span<uint8_t >(static_cast <uint8_t *>(buffer_ptr_), buffer_size_);
32
- data_sink_ = std::make_unique<executorch::etdump::BufferDataSink>(buffer_);
33
+ Result<BufferDataSink> buffer_data_sink_ret =
34
+ BufferDataSink::create (buffer_);
35
+ ASSERT_EQ (buffer_data_sink_ret.error (), Error::Ok);
36
+ buffer_data_sink_ =
37
+ std::make_unique<BufferDataSink>(std::move (buffer_data_sink_ret.get ()));
33
38
}
34
39
35
40
void TearDown () override {
@@ -39,11 +44,11 @@ class BufferDataSinkTest : public ::testing::Test {
39
44
size_t buffer_size_;
40
45
void * buffer_ptr_;
41
46
Span<uint8_t > buffer_;
42
- std::unique_ptr<executorch::etdump:: BufferDataSink> data_sink_ ;
47
+ std::unique_ptr<BufferDataSink> buffer_data_sink_ ;
43
48
};
44
49
45
50
TEST_F (BufferDataSinkTest, StorageSizeCheck) {
46
- Result<size_t > ret = data_sink_ ->get_storage_size ();
51
+ Result<size_t > ret = buffer_data_sink_ ->get_storage_size ();
47
52
ASSERT_EQ (ret.error (), Error::Ok);
48
53
49
54
size_t storage_size = ret.get ();
@@ -55,7 +60,7 @@ TEST_F(BufferDataSinkTest, WriteOneTensorAndCheckData) {
55
60
Tensor tensor = tf.make ({1 , 4 }, {1.0 , 2.0 , 3.0 , 4.0 });
56
61
57
62
Result<size_t > ret =
58
- data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
63
+ buffer_data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
59
64
ASSERT_EQ (ret.error (), Error::Ok);
60
65
61
66
size_t offset = ret.get ();
@@ -75,9 +80,10 @@ TEST_F(BufferDataSinkTest, WriteMultiTensorsAndCheckData) {
75
80
std::vector<Tensor> tensors = {
76
81
tf.make ({1 , 4 }, {1.0 , 2.0 , 3.0 , 4.0 }),
77
82
tf.make ({1 , 4 }, {5.0 , 6.0 , 7.0 , 8.0 })};
83
+
78
84
for (const auto & tensor : tensors) {
79
85
Result<size_t > ret =
80
- data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
86
+ buffer_data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
81
87
ASSERT_EQ (ret.error (), Error::Ok);
82
88
83
89
size_t offset = ret.get ();
@@ -94,8 +100,9 @@ TEST_F(BufferDataSinkTest, WriteMultiTensorsAndCheckData) {
94
100
TEST_F (BufferDataSinkTest, PointerAlignmentCheck) {
95
101
TensorFactory<ScalarType::Float> tf;
96
102
Tensor tensor = tf.make ({1 , 4 }, {1.0 , 2.0 , 3.0 , 4.0 });
103
+
97
104
Result<size_t > ret =
98
- data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
105
+ buffer_data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
99
106
ASSERT_EQ (ret.error (), Error::Ok);
100
107
101
108
size_t offset = ret.get ();
@@ -112,12 +119,32 @@ TEST_F(BufferDataSinkTest, WriteUntilOverflow) {
112
119
// Write tensors until we run out of space
113
120
for (size_t i = 0 ; i < 2 ; i++) {
114
121
Result<size_t > ret =
115
- data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
122
+ buffer_data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
116
123
ASSERT_EQ (ret.error (), Error::Ok);
117
124
}
118
125
119
126
// Attempting to write another tensor should raise an error
120
127
Result<size_t > ret =
121
- data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
128
+ buffer_data_sink_ ->write (tensor.const_data_ptr (), tensor.nbytes ());
122
129
ASSERT_EQ (ret.error (), Error::OutOfResources);
123
130
}
131
+
132
+ TEST_F (BufferDataSinkTest, illegalAlignment) {
133
+ // Create a buffer_data_sink_ with legal alignment that is a power of 2 and
134
+ // greater than 0
135
+ for (size_t i = 1 ; i <= 128 ; i <<= 1 ) {
136
+ Result<BufferDataSink> buffer_data_sink_ret =
137
+ BufferDataSink::create (buffer_, i);
138
+ ASSERT_EQ (buffer_data_sink_ret.error (), Error::Ok);
139
+ }
140
+
141
+ // Create a buffer_data_sink_ with illegal alignment that is not a power of 2
142
+ // or greater than 0
143
+ std::vector<size_t > illegal_alignments = {0 , 3 , 5 , 7 , 100 , 127 };
144
+
145
+ for (size_t i = 0 ; i < illegal_alignments.size (); i++) {
146
+ Result<BufferDataSink> buffer_data_sink_ret =
147
+ BufferDataSink::create (buffer_, illegal_alignments[i]);
148
+ ASSERT_EQ (buffer_data_sink_ret.error (), Error::InvalidArgument);
149
+ }
150
+ }
0 commit comments