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, sizeof(tdm_layer*) * layer_count);
- 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;
}
}
void TDMLayer::TearDown(void)
{
for (int l = 0; l < layer_count; l++) {
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
}
free(layers);
for (int l = 0; l < layer_count; l++) {
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
}
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(output, NULL);
}
TEST_P(TDMLayer, LayerGetOutputNullParam)
for (int l = 0; l < layer_count; l++) {
tdm_output *output = tdm_layer_get_output(layers[l], NULL);
- ASSERT_NE(output, NULL);
+ EXPECT_NE(output, NULL);
}
}
for (int l = 0; l < layer_count; l++) {
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
- ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
+ EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_layers);
tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capabilities, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetCapabilitiesNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetAvailableFormats)
continue;
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
- ASSERT_NE(formats, NULL);
- ASSERT_GT(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
+ EXPECT_NE(formats, NULL);
+ EXPECT_GT(count, 0);
}
}
const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
TDM_UT_SKIP_FLAG(has_layers);
if (!tc_tdm_layer_is_avaiable(layers[0]))
return;
- ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetAvailableProperties)
continue;
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0)
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
}
}
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
- ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetZpos)
TDM_UT_SKIP_FLAG(has_layers);
bool *check_table = (bool*)calloc(layer_count, output_count);
- ASSERT_NE(check_table, NULL);
+ EXPECT_NE(check_table, NULL);
for (int l = 0; l < layer_count; l++) {
if (!tc_tdm_layer_is_avaiable(layers[l]))
TDM_UT_SKIP_FLAG(has_layers);
int zpos = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(zpos, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetZposNullParam)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, DISABLED_LayerSetProperty)
{
tdm_value value = {.s32 = 0};
- ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetProperty)
const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
int count = TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
- ASSERT_GE(count, 0);
+ EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
+ EXPECT_GE(count, 0);
if (count > 0) {
- ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
+ EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
for (int i = 0; i < count; i++) {
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
- ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
+ EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE);
}
}
}
TDM_UT_SKIP_FLAG(has_layers);
tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
- ASSERT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetPropertyNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetInfo)
continue;
tdm_info_layer info;
- ASSERT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
- ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
+ EXPECT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
}
}
tdm_info_layer info;
memset(&info, 0, sizeof info);
- ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetInfoNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, DISABLED_LayerGetInfo)
tdm_info_layer temp;
- ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetInfoNullParam)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerGetBufferFlags)
continue;
unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
- ASSERT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
+ EXPECT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
}
}
TDM_UT_SKIP_FLAG(has_layers);
unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerGetBufferFlagsNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
static void
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- 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 100 times */
for (int t = 0; t < 10; t++) {
tbm_surface_h displaying_buffer = NULL;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
while (displaying_buffer != buffers[next_buffer]) {
- 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(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
next_buffer++;
if (next_buffer == 3)
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- 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 10 times */
for (int t = 0; t < 10; t++) {
tbm_surface_h displaying_buffer = NULL;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
while (displaying_buffer != buffers[next_buffer]) {
- 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(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
next_buffer++;
if (next_buffer == 3)
TDM_UT_SKIP_FLAG(has_layers);
tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetBufferNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBuffer)
if (!tc_tdm_layer_is_avaiable(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit)
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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 10 times */
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
if (next_buffer == 3)
next_buffer = 0;
}
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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 10 times */
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_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);
}
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- 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 10 times */
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
done = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_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);
}
- ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
next_buffer = 0;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[0], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (!tc_tdm_output_is_connected(output))
return;
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerCommitNullOther)
tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
- ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerIsCommittingNullObject)
TDM_UT_SKIP_FLAG(has_layers);
unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerIsCommittingNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerRemoveCommitHandler)
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
+ EXPECT_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_set_buffer(layers[l], buffers[0]), true);
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
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);
}
}
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
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);
}
}
}
bool *done = (bool*)user_data;
if (done)
*done = true;
- ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
tdm_error ret;
tdm_output *output = tdm_layer_get_output(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
- ASSERT_NE(output, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_NE(output, NULL);
if (tc_tdm_layer_is_cursor_layer(layers[l]))
continue;
for (int t = 0; t < 10; t++) {
bool done1 = false, done2 = false, done3 = false;
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
- ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
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);
}
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
}
TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject)
tbm_surface_h displaying_buffer;
tdm_error ret;
displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(displaying_buffer, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(displaying_buffer, NULL);
}
TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther)
tbm_surface_h displaying_buffer;
displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL);
- ASSERT_EQ(displaying_buffer, NULL);
+ EXPECT_EQ(displaying_buffer, NULL);
}
TEST_P(TDMLayer, LayerIsUsableNullObject)
TDM_UT_SKIP_FLAG(has_layers);
unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
+ EXPECT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
}
TEST_P(TDMLayer, LayerSetBufferQueue)
if (tc_tdm_layer_is_primary_layer(layers[l]))
continue;
- ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
- ASSERT_NE(buffer_queue, NULL);
+ EXPECT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
+ EXPECT_NE(buffer_queue, NULL);
- ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
+ EXPECT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
- ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
for (int t = 0; t < 10; t++) {
- ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
- ASSERT_NE(buffer, NULL);
+ EXPECT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
+ EXPECT_NE(buffer, NULL);
tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
+ EXPECT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
displaying_buffer = NULL;
while (displaying_buffer != buffer) {
- 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(layers[l], &ret);
- ASSERT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
}
}
- ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
DestroyBuffers();
}
tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE;
- ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetBufferQueueNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerIsUsableNullOther)
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetVideoPos)
if (!tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
+ EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
}
}
{
TDM_UT_SKIP_FLAG(has_layers);
- ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
}
TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer)
if (tc_tdm_layer_is_video_layer(layers[l]))
continue;
- ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
+ EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
}
}
capture = tdm_layer_create_capture(layers[l], &ret);
if (ret == TDM_ERROR_NONE)
- ASSERT_NE(capture, NULL);
+ EXPECT_NE(capture, NULL);
}
}
tdm_error ret;
tdm_capture *capture = tdm_layer_create_capture(NULL, &ret);
- ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(capture, NULL);
+ EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(capture, NULL);
}
#ifdef TDM_UT_TEST_WITH_PARAMS
projects / platform / core / uifw / libtdm.git / blobdiff