TDMBackendEnv::SetUp();
dpy = tdm_display_init(&ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(dpy, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(dpy, NULL);
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
- ASSERT_GE(output_count, 0);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_GE(output_count, 0);
if (output_count > 0) {
outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
- ASSERT_NE(outputs, NULL);
+ EXPECT_NE(outputs, NULL);
for (int o = 0; o < output_count; o++) {
tdm_error ret;
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
outputs[o] = output;
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
layer_count += count;
layers = (tdm_layer**)realloc(layers, layer_count * sizeof(tdm_layer*));
- ASSERT_NE(layers, NULL);
+ EXPECT_NE(layers, NULL);
for (int l = 0; l < count; l++) {
tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
- ASSERT_NE(layer, NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(layer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
layers[old_layer_count + l] = layer;
}
}
DestroyBuffers();
- ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
+ EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
TDMBackendEnv::TearDown();
}
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs().");
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o);
}
}
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
int layer_count = 0;
- ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(layer_count > 0,
"layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().",
layer_count, o);
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
const tdm_prop *props = NULL;
int prop_count = 0;
- ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
if (prop_count > 0)
TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o);
for (int p = 0; p < prop_count; p++) {
tdm_value value;
value.s32 = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
"Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().",
o, props[p].id);
tdm_error ret;
int output_count = 0;
- ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
for (int o = 0; o < output_count; o++) {
tdm_output *output = tdm_display_get_output(dpy, o, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
int layer_count = 0;
- ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
for (int l = 0; l < layer_count; l++) {
tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
const tdm_prop *props = NULL;
int prop_count = 0;
- ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
if (prop_count > 0)
TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l);
for (int p = 0; p < prop_count; p++) {
tdm_value value;
value.s32 = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
"Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().",
o, l, props[p].id);
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
}
if (!set_mode && best)
set_mode = best;
- ASSERT_NE(set_mode, NULL);
+ EXPECT_NE(set_mode, NULL);
- ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()");
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
- ASSERT_GT(count, 0);
- ASSERT_NE(modes, NULL);
+ EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
+ EXPECT_GT(count, 0);
+ EXPECT_NE(modes, NULL);
for (int i = 0; i < count; i++) {
if (!best)
if (!set_mode && best)
set_mode = best;
- ASSERT_NE(set_mode, NULL);
- ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
- ASSERT_EQ(set_mode, got_mode);
+ EXPECT_NE(set_mode, NULL);
+ EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
+ EXPECT_EQ(set_mode, got_mode);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
TDM_UT_ASSERT_TRUE(set_dpms == got_dpms, "The dpms value which is set and got are different. Check output_set_dpms(), output_get_dpms()");
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
next_buffer++;
if (next_buffer == 3)
TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
bool done = false;
TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
retry:
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
DestroyBuffers();
}
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o);
for (int l = 0; l < layer_count; l++)
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
for (int l = 0; l < layer_count; l++) {
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
retry:
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
next_buffer++;
if (next_buffer == 3)
TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
usleep(40000); /* 40 ms */
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
done = false;
start = tdm_helper_get_time();
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
DestroyBuffers();
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
}
/* start from 1 */
interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
done1 = done2 = done3 = false;
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
start = tdm_helper_get_time();
while (!done1 || !done2 || !done3)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
/* "+ interval" consider the delay of socket communication between kernel and platform */
int max_w = 0;
int max_h = 0;
int preferred_align = 0;
- ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, 0);
- ASSERT_NE(min_h, 0);
- ASSERT_NE(max_w, 0);
- ASSERT_NE(max_h, 0);
- ASSERT_NE(preferred_align, 0);
+ EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, 0);
+ EXPECT_NE(min_h, 0);
+ EXPECT_NE(max_w, 0);
+ EXPECT_NE(max_h, 0);
+ EXPECT_NE(preferred_align, 0);
}
TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
tdm_error ret;
unsigned int has_capability = 0;
- ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
if (!has_capability) {
TDM_UT_INFO("Capture not supported. (output: %d)", o);
continue;
int max_w = 0;
int max_h = 0;
int preferred_align = 0;
- ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
- ASSERT_NE(min_w, 0);
- ASSERT_NE(min_h, 0);
- ASSERT_NE(max_w, 0);
- ASSERT_NE(max_h, 0);
- ASSERT_NE(preferred_align, 0);
+ EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
+ EXPECT_NE(min_w, 0);
+ EXPECT_NE(min_h, 0);
+ EXPECT_NE(max_w, 0);
+ EXPECT_NE(max_h, 0);
+ EXPECT_NE(preferred_align, 0);
}
TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
TDM_UT_SKIP_FLAG(0);
layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for 60 times */
for (int t = 0; t < 60; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
DestroyBuffers();
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
int diffw = mode->hdisplay / (format_count + 2);
int h = mode->vdisplay - diffh * (f + 1);
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), w, h, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
continue;
}
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
info.dst_pos.w = mode->hdisplay;
info.dst_pos.h = mode->vdisplay;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
info.dst_pos.w = TDM_UT_BUFFER_SIZE;
info.dst_pos.h = TDM_UT_BUFFER_SIZE;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
if (output_count > 0) {
if (tc_tdm_output_is_hwc_enable(outputs[0])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
TDM_UT_SKIP_FLAG(0);
}
}
layer = layers[l];
output = tdm_layer_get_output(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
if (!tc_tdm_output_is_connected(output))
continue;
TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- ASSERT_NE(mode, NULL);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
+ EXPECT_NE(mode, NULL);
- ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
for (int f = 0; f < format_count; f++) {
retry:
TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
info.dst_pos.w = info.src_config.pos.w;
info.dst_pos.h = info.src_config.pos.h;
info.transform = TDM_TRANSFORM_NORMAL;
- ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
/* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
tbm_surface_h displaying_buffer;
- ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
done = false;
- ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
while (!done)
- ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
next_buffer++;
if (next_buffer == 3)
next_buffer = 0;
FOURCC_STR(formats[f]), pipe, l);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
}
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
/* should be debugged int emulator kernel */
TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
if (tc_tdm_output_is_hwc_enable(outputs[o]))
TDM_UT_SKIP_FLAG(0);
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
+ EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
TDM_UT_SKIP_FLAG(0);
}
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
- ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
}
}
TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
{
- ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
+ EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
for (int o = 0; o < output_count; o++) {
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
if (tc_tdm_output_is_hwc_enable(outputs[o])) {
- ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
+ EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
TDM_UT_SKIP_FLAG(0);
}
tdm_error ret;
tdm_info_layer info, temp;
tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
- ASSERT_NE(layer, NULL);
+ EXPECT_NE(layer, NULL);
displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- ASSERT_NE(displaying_buffer, NULL);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
- ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
- ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0);
+ EXPECT_NE(displaying_buffer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
+ EXPECT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
+ EXPECT_EQ(memcmp(&info, &temp, sizeof info), 0);
}
}
projects / platform / core / uifw / libtdm.git / blobdiff