/* Check that two RTC devices can be used independently */
static int dm_test_rtc_dual(struct dm_test_state *dms)
{
struct rtc_time now1, now2, cmp;
struct udevice *dev1, *dev2;
struct udevice *emul1, *emul2;
long offset;
ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1));
ut_assertok(dm_rtc_get(dev1, &now1));
ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2));
ut_assertok(dm_rtc_get(dev2, &now2));
ut_assertok(device_find_first_child(dev1, &emul1));
ut_assert(emul1 != NULL);
ut_assertok(device_find_first_child(dev2, &emul2));
ut_assert(emul2 != NULL);
offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);
sandbox_i2c_rtc_set_offset(emul2, false, offset + 1);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev2, &cmp));
ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false));
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev1, &cmp));
ut_assertok(cmp_times(&now1, &cmp, true));
return 0;
}
/* Set and get the time */
static int dm_test_rtc_set_get(struct dm_test_state *dms)
{
struct rtc_time now, time, cmp;
struct udevice *dev, *emul;
long offset, old_offset, old_base_time;
ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
ut_assertok(dm_rtc_get(dev, &now));
ut_assertok(device_find_first_child(dev, &emul));
ut_assert(emul != NULL);
/* Tell the RTC to go into manual mode */
old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
memset(&time, '\0', sizeof(time));
time.tm_mday = 25;
time.tm_mon = 8;
time.tm_year = 2004;
time.tm_sec = 0;
time.tm_min = 18;
time.tm_hour = 18;
ut_assertok(dm_rtc_set(dev, &time));
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&time, &cmp, true));
/* Increment by 1 second */
offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
sandbox_i2c_rtc_set_offset(emul, false, offset + 1);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_asserteq(1, cmp.tm_sec);
/* Check against original offset */
sandbox_i2c_rtc_set_offset(emul, false, old_offset);
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&now, &cmp, true));
/* Back to the original offset */
sandbox_i2c_rtc_set_offset(emul, false, 0);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&now, &cmp, true));
/* Increment the base time by 1 emul */
sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
if (now.tm_sec == 59) {
ut_asserteq(0, cmp.tm_sec);
} else {
ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
}
old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);
return 0;
}
void diff_files( char* file_name_a, char* file_name_b, int verbosity ) {
bool finished = false;
bool print_diff_info = verbosity > 0 ? true : false;
bool print_file_info = verbosity > 1 ? true : false;
seed_file_info file_info_a;
seed_file_info file_info_b;
char* file_name_original;
char* file_name_updated;
list_t list_global_original;
list_t list_global_updated;
list_t list_fixed_original;
list_t list_fixed_updated;
list_t list_log_original;
list_t list_log_updated;
list_t list_token_context_original;
list_t list_token_context_updated;
list_t list_global;
list_t list_fixed;
list_t list_log;
list_t list_token_context;
printf( "Retrieving file info\n" );
get_seed_file_info( file_name_a, &file_info_a, print_file_info );
get_seed_file_info( file_name_b, &file_info_b, print_file_info );
if ( print_file_info ) {
print_seed_time( "File A Start Time ", &file_info_a.start_time, "\n" );
print_seed_time( "File A End Time ", &file_info_a.end_time, "\n" );
print_seed_time( "File B Start Time ", &file_info_b.start_time, "\n" );
print_seed_time( "File B End Time ", &file_info_b.end_time, "\n" );
}
printf( "Comparing file times\n" );
if ( cmp_times( &file_info_a.start_time, &file_info_a.end_time ) > 0 ||
cmp_times( &file_info_b.start_time, &file_info_b.end_time ) > 0 ||
cmp_times( &file_info_a.start_time, &file_info_b.start_time ) == 0 ||
cmp_times( &file_info_a.start_time, &file_info_b.end_time ) == 0 ||
cmp_times( &file_info_a.end_time, &file_info_b.start_time ) == 0 ||
cmp_times( &file_info_a.end_time, &file_info_b.end_time ) == 0 ) {
printf( "File times too close\n" );
goto cleanup;
}
else if ( cmp_times( &file_info_a.end_time, &file_info_b.start_time ) < 0 ) {
file_name_original = file_name_a;
file_name_updated = file_name_b;
}
else if ( cmp_times( &file_info_b.end_time, &file_info_a.start_time ) < 0 ) {
file_name_original = file_name_b;
file_name_updated = file_name_a;
}
else {
printf( "File times not as expected\n" );
goto cleanup;
}
printf( "Initializing lists\n" );
if ( list_init( &list_global_original ) ||
list_init( &list_fixed_original ) ||
list_init( &list_log_original ) ||
list_init( &list_token_context_original ) ||
list_init( &list_global_updated ) ||
list_init( &list_fixed_updated ) ||
list_init( &list_log_updated ) ||
list_init( &list_token_context_updated ) ||
list_init( &list_global ) ||
list_init( &list_fixed ) ||
list_init( &list_log ) ||
list_init( &list_token_context ) ) {
goto cleanup;
}
list_attributes_comparator( &list_global_original, metadata_compare );
list_attributes_comparator( &list_fixed_original, metadata_compare );
list_attributes_comparator( &list_log_original, metadata_compare );
list_attributes_comparator( &list_token_context_original, metadata_compare );
list_attributes_comparator( &list_global_updated, metadata_compare );
list_attributes_comparator( &list_fixed_updated, metadata_compare );
list_attributes_comparator( &list_log_updated, metadata_compare );
list_attributes_comparator( &list_token_context_updated, metadata_compare );
list_attributes_comparator( &list_global, metadata_compare );
list_attributes_comparator( &list_fixed, metadata_compare );
list_attributes_comparator( &list_log, metadata_compare );
list_attributes_comparator( &list_token_context, metadata_compare );
printf( "Populating lists\n" );
/* Loop through file, comparing records as we go */
populate_records( file_name_original,
&list_global_original,
&list_fixed_original,
&list_log_original,
&list_token_context_original,
print_file_info );
populate_records( file_name_updated,
&list_global_updated,
&list_fixed_updated,
&list_log_updated,
&list_token_context_updated,
print_file_info );
printf( "Sorting lists\n" );
list_sort( &list_global_original, LIST_ORDER_S2L );
list_sort( &list_fixed_original, LIST_ORDER_S2L );
list_sort( &list_log_original, LIST_ORDER_S2L );
list_sort( &list_token_context_original, LIST_ORDER_S2L );
list_sort( &list_global_updated, LIST_ORDER_S2L );
list_sort( &list_fixed_updated, LIST_ORDER_S2L );
list_sort( &list_log_updated, LIST_ORDER_S2L );
list_sort( &list_token_context_updated, LIST_ORDER_S2L );
printf( "Populating test lists\n" );
list_prepend( &list_global, list_get_max(&list_global_original) );
list_append( &list_global, list_get_min(&list_global_updated) );
list_prepend( &list_fixed, list_get_max(&list_fixed_original) );
list_append( &list_fixed, list_get_min(&list_fixed_updated) );
list_prepend( &list_log, list_get_max(&list_log_original) );
list_append( &list_log, list_get_min(&list_log_updated) );
list_prepend( &list_token_context, list_get_max(&list_token_context_original) );
list_append( &list_token_context, list_get_min(&list_token_context_updated) );
list_sort( &list_global, LIST_ORDER_S2L );
list_sort( &list_fixed, LIST_ORDER_S2L );
list_sort( &list_log, LIST_ORDER_S2L );
list_sort( &list_token_context, LIST_ORDER_S2L );
printf( "Comparing lists\n" );
diff_list_global( &list_global, print_diff_info );
diff_list_fixed( &list_fixed, print_diff_info );
diff_list_log( &list_log, print_diff_info );
diff_list_tokens( &list_token_context, print_diff_info );
goto finish;
cleanup:
fprintf( stderr, "Either a list initialization failed, "
"or the files were incompatable.\n" );
list_destroy(&list_global_original);
list_destroy(&list_fixed_original);
list_destroy(&list_log_original);
list_destroy(&list_token_context_original);
list_destroy(&list_global_updated);
list_destroy(&list_fixed_updated);
list_destroy(&list_log_updated);
list_destroy(&list_token_context_updated);
list_destroy(&list_global);
list_destroy(&list_fixed);
list_destroy(&list_log);
list_destroy(&list_token_context);
finish:
return;
}
