Skip to content

Fix rtc api time conversion #4499

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 6 commits into from
Jun 8, 2017
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
245 changes: 245 additions & 0 deletions TESTS/mbed_hal/rtc_time/main.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,245 @@
/* mbed Microcontroller Library
* Copyright (c) 2017 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include "utest/utest.h"
#include "unity/unity.h"
#include "greentea-client/test_env.h"

#include "mbed.h"
#include "mbed_mktime.h"

using namespace utest::v1;

/*
* regular is_leap_year, see platform/mbed_mktime.c for the optimized version
*/
bool is_leap_year(int year) {
year = 1900 + year;
if (year % 4) {
return false;
} else if (year % 100) {
return true;
} else if (year % 400) {
return false;
}
return true;
}

/*
* Test the optimized version of _rtc_is_leap_year against the generic version.
*/
void test_is_leap_year() {
for (int i = 70; i < 138; ++i) {
bool expected = is_leap_year(i);
bool actual_value = _rtc_is_leap_year(i);

if (expected != actual_value) {
printf ("leap year failed with i = %d\r\n", i);
}
TEST_ASSERT_EQUAL(expected, actual_value);
}
}

struct tm make_time_info(int year, int month, int day, int hours, int minutes, int seconds) {
struct tm timeinfo;
timeinfo.tm_year = year;
timeinfo.tm_mon = month;
timeinfo.tm_mday = day;
timeinfo.tm_hour = hours;
timeinfo.tm_min = minutes;
timeinfo.tm_sec = seconds;
return timeinfo;
}

/*
* test out of range values for _rtc_mktime.
* The function operates from the 1st of january 1970 at 00:00:00 to the 19th
* of january 2038 at 03:14:07.
*/
void test_mk_time_out_of_range() {
tm invalid_lower_bound = make_time_info(
69,
11,
31,
23,
59,
59
);

tm valid_lower_bound = make_time_info(
70,
0,
1,
0,
0,
0
);

tm valid_upper_bound = make_time_info(
138,
0,
19,
3,
14,
7
);

tm invalid_upper_bound = make_time_info(
138,
0,
19,
3,
14,
8
);

TEST_ASSERT_EQUAL_INT(((time_t) -1), _rtc_mktime(&invalid_lower_bound));
TEST_ASSERT_EQUAL_INT(((time_t) 0), _rtc_mktime(&valid_lower_bound));
TEST_ASSERT_EQUAL_INT(((time_t) INT_MAX), _rtc_mktime(&valid_upper_bound));
TEST_ASSERT_EQUAL_INT(((time_t) -1), _rtc_mktime(&invalid_upper_bound));
}

/*
* test mktime over a large set of values
*/
void test_mk_time() {
for (size_t year = 70; year < 137; ++year) {
for (size_t month = 0; month < 12; ++month) {
for (size_t day = 1; day < 32; ++day) {
if (month == 1 && is_leap_year(year) && day == 29) {
break;
} else if(month == 1 && !is_leap_year(year) && day == 28) {
break;
} else if (
day == 31 &&
(month == 3 || month == 5 || month == 8 || month == 10)
) {
break;
}

for (size_t hour = 0; hour < 24; ++hour) {
tm time_info = make_time_info(
year,
month,
day,
hour,
hour % 2 ? 59 : 0,
hour % 2 ? 59 : 0
);

time_t expected = mktime(&time_info);
time_t actual_value = _rtc_mktime(&time_info);

char msg[128] = "";
if (expected != actual_value) {
snprintf(
msg, sizeof(msg),
"year = %d, month = %d, day = %d, diff = %ld",
year, month, day, expected - actual_value
);
}

TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual_value, msg);
}
}
}
}
}

/*
* test value out of range for localtime
*/
void test_local_time_limit() {
struct tm dummy_value;
TEST_ASSERT_FALSE(_rtc_localtime((time_t) -1, &dummy_value));
TEST_ASSERT_FALSE(_rtc_localtime((time_t) INT_MIN, &dummy_value));
}

/*
* test _rtc_localtime over a large set of values.
*/
void test_local_time() {
for (uint32_t i = 0; i < INT_MAX; i += 3451) {
time_t copy = (time_t) i;
struct tm* expected = localtime(&copy);
struct tm actual_value;
bool result = _rtc_localtime((time_t) i, &actual_value);

if (
expected->tm_sec != actual_value.tm_sec ||
expected->tm_min != actual_value.tm_min ||
expected->tm_hour != actual_value.tm_hour ||
expected->tm_mday != actual_value.tm_mday ||
expected->tm_mon != actual_value.tm_mon ||
expected->tm_year != actual_value.tm_year ||
expected->tm_wday != actual_value.tm_wday ||
expected->tm_yday != actual_value.tm_yday ||
result == false
) {
printf("error: i = %lu\r\n", i);
}

TEST_ASSERT_TRUE(result);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_sec, actual_value.tm_sec, "invalid seconds"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_min, actual_value.tm_min, "invalid minutes"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_hour, actual_value.tm_hour, "invalid hours"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_mday, actual_value.tm_mday, "invalid day"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_mon, actual_value.tm_mon, "invalid month"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_year, actual_value.tm_year, "invalid year"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_wday, actual_value.tm_wday, "invalid weekday"
);
TEST_ASSERT_EQUAL_UINT32_MESSAGE(
expected->tm_yday, actual_value.tm_yday, "invalid year day"
);
}
}

utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
greentea_case_failure_abort_handler(source, reason);
return STATUS_CONTINUE;
}

Case cases[] = {
Case("test is leap year", test_is_leap_year, greentea_failure_handler),
Case("test mk time out of range values", test_mk_time_out_of_range, greentea_failure_handler),
Case("mk time", test_mk_time, greentea_failure_handler),
Case("test local time", test_local_time, greentea_failure_handler),
Case("test local time limits", test_local_time_limit, greentea_failure_handler),
};

utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
GREENTEA_SETUP(1200, "default_auto");
return greentea_test_setup_handler(number_of_cases);
}

Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);

int main() {
return Harness::run(specification);
}
Loading