Skip to content

Commit 11e92b2

Browse files
RossBruntonRossBrunton
authored
[UR][CTS] Use ASSERT instead of EXPECT in test bodies (#19494)
`EXPECT` doesn't return from the current function, so a number of tests would keep going if they failed, in one case segfaulting due to writing to memory that was not allocated correctly. Standardise the test suite so that it always returns on the first failure using `ASSERT` where possible.
1 parent 8f06a1d commit 11e92b2

26 files changed

Lines changed: 101 additions & 101 deletions

‎unified-runtime/test/conformance/adapter/urAdapterRelease.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ TEST_P(urAdapterReleaseTest, Success) {
1818
&referenceCountBefore, nullptr));
1919

2020
uint32_t referenceCountAfter = 0;
21-
EXPECT_SUCCESS(urAdapterRelease(adapter));
21+
ASSERT_SUCCESS(urAdapterRelease(adapter));
2222
ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_REFERENCE_COUNT,
2323
sizeof(referenceCountAfter),
2424
&referenceCountAfter, nullptr));

‎unified-runtime/test/conformance/adapter/urAdapterRetain.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ TEST_P(urAdapterRetainTest, Success) {
1717
&referenceCountBefore, nullptr));
1818

1919
uint32_t referenceCountAfter = 0;
20-
EXPECT_SUCCESS(urAdapterRetain(adapter));
20+
ASSERT_SUCCESS(urAdapterRetain(adapter));
2121
ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_REFERENCE_COUNT,
2222
sizeof(referenceCountAfter),
2323
&referenceCountAfter, nullptr));

‎unified-runtime/test/conformance/context/urContextRetain.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ TEST_P(urContextRetainTest, Success) {
2020

2121
ASSERT_LT(prevRefCount, refCount);
2222

23-
EXPECT_SUCCESS(urContextRelease(context));
23+
ASSERT_SUCCESS(urContextRelease(context));
2424
}
2525

2626
TEST_P(urContextRetainTest, InvalidNullHandleContext) {

‎unified-runtime/test/conformance/device/urDeviceRelease.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ TEST_P(urDeviceReleaseTest, Success) {
1212
uint32_t prevRefCount = 0;
1313
ASSERT_SUCCESS(uur::GetObjectReferenceCount(device, prevRefCount));
1414

15-
EXPECT_SUCCESS(urDeviceRelease(device));
15+
ASSERT_SUCCESS(urDeviceRelease(device));
1616

1717
uint32_t refCount = 0;
1818
ASSERT_SUCCESS(uur::GetObjectReferenceCount(device, refCount));
@@ -46,14 +46,14 @@ TEST_P(urDeviceReleaseTest, SuccessSubdevices) {
4646
uint32_t prevRefCount = 0;
4747
ASSERT_SUCCESS(uur::GetObjectReferenceCount(sub_device, prevRefCount));
4848

49-
EXPECT_SUCCESS(urDeviceRelease(sub_device));
49+
ASSERT_SUCCESS(urDeviceRelease(sub_device));
5050

5151
uint32_t refCount = 0;
5252
ASSERT_SUCCESS(uur::GetObjectReferenceCount(sub_device, refCount));
5353

5454
ASSERT_GT(prevRefCount, refCount);
5555

56-
EXPECT_SUCCESS(urDeviceRelease(sub_device));
56+
ASSERT_SUCCESS(urDeviceRelease(sub_device));
5757
}
5858

5959
TEST_P(urDeviceReleaseTest, InvalidNullHandle) {

‎unified-runtime/test/conformance/device/urDeviceRetain.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,8 @@ TEST_P(urDeviceRetainTest, SuccessSubdevices) {
5151

5252
ASSERT_LT(prevRefCount, refCount);
5353

54-
EXPECT_SUCCESS(urDeviceRelease(sub_device));
55-
EXPECT_SUCCESS(urDeviceRelease(sub_device));
54+
ASSERT_SUCCESS(urDeviceRelease(sub_device));
55+
ASSERT_SUCCESS(urDeviceRelease(sub_device));
5656
}
5757

5858
TEST_P(urDeviceRetainTest, InvalidNullHandle) {

‎unified-runtime/test/conformance/enqueue/urEnqueueEventsWait.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -92,9 +92,9 @@ TEST_P(urEnqueueEventsWaitTest, Success) {
9292
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue2, dst_buffer, true, 0, size,
9393
output.data(), 0, nullptr, nullptr));
9494
ASSERT_EQ(input, output);
95-
EXPECT_SUCCESS(urEventRelease(event1));
96-
EXPECT_SUCCESS(urEventRelease(waitEvent));
97-
EXPECT_SUCCESS(urEventRelease(event2));
95+
ASSERT_SUCCESS(urEventRelease(event1));
96+
ASSERT_SUCCESS(urEventRelease(waitEvent));
97+
ASSERT_SUCCESS(urEventRelease(event2));
9898
}
9999

100100
TEST_P(urEnqueueEventsWaitTest, InvalidNullHandleQueue) {

‎unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitWithBarrier.cpp‎

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -41,10 +41,10 @@ struct urEnqueueEventsWaitWithBarrierTest
4141

4242
void TearDown() override {
4343
if (src_buffer) {
44-
EXPECT_SUCCESS(urMemRelease(src_buffer));
44+
ASSERT_SUCCESS(urMemRelease(src_buffer));
4545
}
4646
if (dst_buffer) {
47-
EXPECT_SUCCESS(urMemRelease(dst_buffer));
47+
ASSERT_SUCCESS(urMemRelease(dst_buffer));
4848
}
4949
urMultiQueueTestWithParam::TearDown();
5050
}
@@ -110,32 +110,32 @@ TEST_P(urEnqueueEventsWaitWithBarrierTest, Success) {
110110
ur_event_handle_t waitEvent = nullptr;
111111
ASSERT_SUCCESS(urEnqueueMemBufferCopy(queue1, src_buffer, dst_buffer, 0, 0,
112112
size, 0, nullptr, &event1));
113-
EXPECT_SUCCESS(EnqueueBarrier(queue2, 1, &event1, &waitEvent));
114-
EXPECT_SUCCESS(urQueueFlush(queue2));
115-
EXPECT_SUCCESS(urQueueFlush(queue1));
116-
EXPECT_SUCCESS(urEventWait(1, &waitEvent));
113+
ASSERT_SUCCESS(EnqueueBarrier(queue2, 1, &event1, &waitEvent));
114+
ASSERT_SUCCESS(urQueueFlush(queue2));
115+
ASSERT_SUCCESS(urQueueFlush(queue1));
116+
ASSERT_SUCCESS(urEventWait(1, &waitEvent));
117117

118118
std::vector<uint32_t> output(count, 1);
119-
EXPECT_SUCCESS(urEnqueueMemBufferRead(queue1, dst_buffer, true, 0, size,
119+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue1, dst_buffer, true, 0, size,
120120
output.data(), 0, nullptr, nullptr));
121121
EXPECT_EQ(input, output);
122-
EXPECT_SUCCESS(urEventRelease(waitEvent));
123-
EXPECT_SUCCESS(urEventRelease(event1));
122+
ASSERT_SUCCESS(urEventRelease(waitEvent));
123+
ASSERT_SUCCESS(urEventRelease(event1));
124124

125125
ur_event_handle_t event2 = nullptr;
126126
input.assign(count, 420);
127-
EXPECT_SUCCESS(urEnqueueMemBufferWrite(queue2, src_buffer, true, 0, size,
127+
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue2, src_buffer, true, 0, size,
128128
input.data(), 0, nullptr, nullptr));
129-
EXPECT_SUCCESS(urEnqueueMemBufferCopy(queue2, src_buffer, dst_buffer, 0, 0,
129+
ASSERT_SUCCESS(urEnqueueMemBufferCopy(queue2, src_buffer, dst_buffer, 0, 0,
130130
size, 0, nullptr, &event2));
131-
EXPECT_SUCCESS(EnqueueBarrier(queue1, 1, &event2, &waitEvent));
132-
EXPECT_SUCCESS(urQueueFlush(queue2));
133-
EXPECT_SUCCESS(urQueueFlush(queue1));
134-
EXPECT_SUCCESS(urEventWait(1, &waitEvent));
135-
EXPECT_SUCCESS(urEnqueueMemBufferRead(queue2, dst_buffer, true, 0, size,
131+
ASSERT_SUCCESS(EnqueueBarrier(queue1, 1, &event2, &waitEvent));
132+
ASSERT_SUCCESS(urQueueFlush(queue2));
133+
ASSERT_SUCCESS(urQueueFlush(queue1));
134+
ASSERT_SUCCESS(urEventWait(1, &waitEvent));
135+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue2, dst_buffer, true, 0, size,
136136
output.data(), 0, nullptr, nullptr));
137-
EXPECT_SUCCESS(urEventRelease(waitEvent));
138-
EXPECT_SUCCESS(urEventRelease(event2));
137+
ASSERT_SUCCESS(urEventRelease(waitEvent));
138+
ASSERT_SUCCESS(urEventRelease(event2));
139139
EXPECT_EQ(input, output);
140140
}
141141

@@ -181,15 +181,15 @@ TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest,
181181
constexpr uint32_t ONE = 1;
182182
urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, 0,
183183
nullptr, &event);
184-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
185-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
184+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
185+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
186186
nullptr, 0, nullptr, 0, nullptr,
187187
&event));
188-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
189-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
188+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
189+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
190190
nullptr, 0, nullptr, 0, nullptr,
191191
&event));
192-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
192+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr));
193193
addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004);
194194
}
195195
}
@@ -212,15 +212,15 @@ TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest,
212212
constexpr uint32_t ONE = 1;
213213
urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, 0,
214214
nullptr, nullptr);
215-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
216-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
215+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
216+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
217217
nullptr, 0, nullptr, 1, &event,
218218
nullptr));
219-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
220-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
219+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
220+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
221221
nullptr, 0, nullptr, 1, &event,
222222
nullptr));
223-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
223+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event));
224224
addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004);
225225
}
226226
}
@@ -242,17 +242,17 @@ TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest, SuccessEventDependencies) {
242242
constexpr uint32_t ONE = 1;
243243
urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, 0,
244244
nullptr, &event[0]);
245-
EXPECT_SUCCESS(
245+
ASSERT_SUCCESS(
246246
urEnqueueEventsWaitWithBarrier(queue, 1, &event[0], &event[1]));
247-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
247+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
248248
nullptr, 0, nullptr, 1, &event[1],
249249
&event[2]));
250-
EXPECT_SUCCESS(
250+
ASSERT_SUCCESS(
251251
urEnqueueEventsWaitWithBarrier(queue, 1, &event[2], &event[3]));
252-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
252+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
253253
nullptr, 0, nullptr, 1, &event[3],
254254
&event[4]));
255-
EXPECT_SUCCESS(
255+
ASSERT_SUCCESS(
256256
urEnqueueEventsWaitWithBarrier(queue, 1, &event[4], &event[5]));
257257
addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004);
258258
}
@@ -275,15 +275,15 @@ TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest,
275275
constexpr uint32_t ONE = 1;
276276
urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, 0,
277277
nullptr, nullptr);
278-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
279-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
278+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
279+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, &count,
280280
nullptr, 0, nullptr, 0, nullptr,
281281
nullptr));
282-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
283-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
282+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
283+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, &count,
284284
nullptr, 0, nullptr, 0, nullptr,
285285
nullptr));
286-
EXPECT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
286+
ASSERT_SUCCESS(urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr));
287287
addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004);
288288
}
289289
}

‎unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunch.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -631,7 +631,7 @@ TEST_P(urEnqueueKernelLaunchMultiDeviceTest, KernelLaunchReadDifferentQueues) {
631631
nullptr, 0, nullptr, nullptr));
632632

633633
// Wait for the queue to finish executing.
634-
EXPECT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
634+
ASSERT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
635635

636636
// Then the remaining queues do blocking reads from the buffer. Since the
637637
// queues target different devices this checks that any devices memory has

‎unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -121,25 +121,25 @@ TEST_P(urEnqueueMemBufferCopyMultiDeviceTest, CopyReadDifferentQueues) {
121121
ur_mem_handle_t dst_buffer = nullptr;
122122
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_ONLY, size,
123123
nullptr, &dst_buffer));
124-
EXPECT_SUCCESS(urEnqueueMemBufferCopy(queues[0], buffer, dst_buffer, 0, 0,
124+
ASSERT_SUCCESS(urEnqueueMemBufferCopy(queues[0], buffer, dst_buffer, 0, 0,
125125
size, 0, nullptr, nullptr));
126126

127127
// Wait for the queue to finish executing.
128-
EXPECT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
128+
ASSERT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
129129

130130
// Then the remaining queues do blocking reads from the buffer. Since the
131131
// queues target different devices this checks that any devices memory has
132132
// been synchronized.
133133
for (unsigned i = 1; i < queues.size(); ++i) {
134134
const auto queue = queues[i];
135135
std::vector<uint32_t> output(count, 0);
136-
EXPECT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer, true, 0, size,
136+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer, true, 0, size,
137137
output.data(), 0, nullptr, nullptr));
138138
for (unsigned j = 0; j < count; ++j) {
139139
EXPECT_EQ(input, output[j])
140140
<< "Result on queue " << i << " did not match at index " << j << "!";
141141
}
142142
}
143143

144-
EXPECT_SUCCESS(urMemRelease(dst_buffer));
144+
ASSERT_SUCCESS(urMemRelease(dst_buffer));
145145
}

‎unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopyRect.cpp‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -101,30 +101,30 @@ TEST_P(urEnqueueMemBufferCopyRectTestWithParam, Success) {
101101
// Fill src buffer with sequentially increasing values.
102102
std::vector<uint8_t> input(src_buffer_size, 0x0);
103103
std::iota(std::begin(input), std::end(input), 0x0);
104-
EXPECT_SUCCESS(urEnqueueMemBufferWrite(queue, src_buffer,
104+
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, src_buffer,
105105
/* is_blocking */ true, 0,
106106
src_buffer_size, input.data(), 0,
107107
nullptr, nullptr));
108108

109109
ur_mem_handle_t dst_buffer = nullptr;
110-
EXPECT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE,
110+
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE,
111111
dst_buffer_size, nullptr, &dst_buffer));
112112

113113
// Zero destination buffer to begin with since the write may not cover the
114114
// whole buffer.
115115
const uint8_t zero = 0x0;
116-
EXPECT_SUCCESS(urEnqueueMemBufferFill(queue, dst_buffer, &zero, sizeof(zero),
116+
ASSERT_SUCCESS(urEnqueueMemBufferFill(queue, dst_buffer, &zero, sizeof(zero),
117117
0, dst_buffer_size, 0, nullptr,
118118
nullptr));
119119

120120
// Enqueue the rectangular copy between the buffers.
121-
EXPECT_SUCCESS(urEnqueueMemBufferCopyRect(
121+
ASSERT_SUCCESS(urEnqueueMemBufferCopyRect(
122122
queue, src_buffer, dst_buffer, src_buffer_origin, dst_buffer_origin,
123123
region, src_buffer_row_pitch, src_buffer_slice_pitch,
124124
dst_buffer_row_pitch, dst_buffer_slice_pitch, 0, nullptr, nullptr));
125125

126126
std::vector<uint8_t> output(dst_buffer_size, 0x0);
127-
EXPECT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer,
127+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer,
128128
/* is_blocking */ true, 0,
129129
dst_buffer_size, output.data(), 0,
130130
nullptr, nullptr));
@@ -139,8 +139,8 @@ TEST_P(urEnqueueMemBufferCopyRectTestWithParam, Success) {
139139
EXPECT_EQ(expected, output);
140140

141141
// Cleanup.
142-
EXPECT_SUCCESS(urMemRelease(src_buffer));
143-
EXPECT_SUCCESS(urMemRelease(dst_buffer));
142+
ASSERT_SUCCESS(urMemRelease(src_buffer));
143+
ASSERT_SUCCESS(urMemRelease(dst_buffer));
144144
}
145145

146146
struct urEnqueueMemBufferCopyRectTest : uur::urQueueTest {
@@ -321,26 +321,26 @@ TEST_P(urEnqueueMemBufferCopyRectMultiDeviceTest, CopyRectReadDifferentQueues) {
321321
ur_mem_handle_t dst_buffer = nullptr;
322322
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_ONLY, size,
323323
nullptr, &dst_buffer));
324-
EXPECT_SUCCESS(urEnqueueMemBufferCopyRect(
324+
ASSERT_SUCCESS(urEnqueueMemBufferCopyRect(
325325
queues[0], buffer, dst_buffer, {0, 0, 0}, {0, 0, 0}, {size, 1, 1}, size,
326326
size, size, size, 0, nullptr, nullptr));
327327

328328
// Wait for the queue to finish executing.
329-
EXPECT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
329+
ASSERT_SUCCESS(urEnqueueEventsWait(queues[0], 0, nullptr, nullptr));
330330

331331
// Then the remaining queues do blocking reads from the buffer. Since the
332332
// queues target different devices this checks that any devices memory has
333333
// been synchronized.
334334
for (unsigned i = 1; i < queues.size(); ++i) {
335335
const auto queue = queues[i];
336336
std::vector<uint32_t> output(count, 0);
337-
EXPECT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer, true, 0, size,
337+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, dst_buffer, true, 0, size,
338338
output.data(), 0, nullptr, nullptr));
339339
for (unsigned j = 0; j < count; ++j) {
340340
EXPECT_EQ(input, output[j])
341341
<< "Result on queue " << i << " did not match at index " << j << "!";
342342
}
343343
}
344344

345-
EXPECT_SUCCESS(urMemRelease(dst_buffer));
345+
ASSERT_SUCCESS(urMemRelease(dst_buffer));
346346
}

0 commit comments

Comments
 (0)