summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/CMakeLists.txt107
-rw-r--r--tests/at-ccfc/ma260.dump3
-rw-r--r--tests/at-statemachine.c97
-rw-r--r--tests/at-ussd/04-unknown.dump1
-rw-r--r--tests/at-ussd/issue178-dell.dump2
-rwxr-xr-xtests/gen-include-test.sh3
-rw-r--r--tests/misc/wap-bookmark.backup2
-rw-r--r--tests/odbc.ini7
-rw-r--r--tests/sms-at-encode.c15
-rw-r--r--tests/smsbackup.c15
10 files changed, 238 insertions, 14 deletions
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 503719f..e435740 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -18,32 +18,38 @@ include_directories("${CMAKE_CURRENT_BINARY_DIR}/../include")
# Basic check for statemachine allocation
add_executable(statemachine-alloc statemachine-alloc.c)
+add_coverage(statemachine-alloc)
target_link_libraries(statemachine-alloc libGammu ${LIBINTL_LIBRARIES})
add_test(statemachine-alloc "${GAMMU_TEST_PATH}/statemachine-alloc${CMAKE_EXECUTABLE_SUFFIX}")
if (BLUETOOTH_RF_SEARCHING)
add_executable(bluetooth_checkservicename bluetooth_checkservicename.c)
+ add_coverage(bluetooth_checkservicename)
target_link_libraries(bluetooth_checkservicename libGammu ${LIBINTL_LIBRARIES})
add_test(bluetooth_checkservicename "${GAMMU_TEST_PATH}/bluetooth_checkservicename${CMAKE_EXECUTABLE_SUFFIX}")
endif (BLUETOOTH_RF_SEARCHING)
# Basic check for sizes
add_executable(sizes sizes.c)
+add_coverage(sizes)
add_test(sizes "${GAMMU_TEST_PATH}/sizes${CMAKE_EXECUTABLE_SUFFIX}")
set_tests_properties(sizes PROPERTIES
FAIL_REGULAR_EXPRESSION "[0-9][0-9] MiB")
add_executable(base64 base64.c)
+add_coverage(base64)
target_link_libraries(base64 libGammu ${LIBINTL_LIBRARIES})
add_test(base64 "${GAMMU_TEST_PATH}/base64${CMAKE_EXECUTABLE_SUFFIX}")
# Array manipulation tests
add_executable(array-test array-test.c)
+add_coverage(array-test)
target_link_libraries (array-test array)
add_test(array "${GAMMU_TEST_PATH}/array-test${CMAKE_EXECUTABLE_SUFFIX}")
# UTF-8 manipulation tests
add_executable(utf-8 utf-8.c)
+add_coverage(utf-8)
target_link_libraries (utf-8 libGammu)
add_test(utf-8 "${GAMMU_TEST_PATH}/utf-8${CMAKE_EXECUTABLE_SUFFIX}")
@@ -62,6 +68,7 @@ if (HAVE_MYSQL_MYSQL_H OR LIBDBI_FOUND OR HAVE_POSTGRESQL_LIBPQ_FE_H)
endif (POSTGRES_FOUND)
add_executable(sql-parse-date sql-parse-date.c)
+ add_coverage(sql-parse-date)
target_link_libraries (sql-parse-date gsmsd)
add_test(sql-parse-date "${GAMMU_TEST_PATH}/sql-parse-date${CMAKE_EXECUTABLE_SUFFIX}")
endif (HAVE_MYSQL_MYSQL_H OR LIBDBI_FOUND OR HAVE_POSTGRESQL_LIBPQ_FE_H)
@@ -69,6 +76,7 @@ endif (HAVE_MYSQL_MYSQL_H OR LIBDBI_FOUND OR HAVE_POSTGRESQL_LIBPQ_FE_H)
# Backup comments
if (WITH_BACKUP)
add_executable(backup-comment backup-comment.c)
+ add_coverage(backup-comment)
target_link_libraries (backup-comment libGammu ${LIBINTL_LIBRARIES})
add_test(backup-comment "${GAMMU_TEST_PATH}/backup-comment${CMAKE_EXECUTABLE_SUFFIX}")
endif (WITH_BACKUP)
@@ -76,6 +84,7 @@ endif (WITH_BACKUP)
# Backup reading
if (WITH_BACKUP)
add_executable(read-backup read-backup.c)
+ add_coverage(read-backup)
target_link_libraries (read-backup libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -94,44 +103,52 @@ endif (WITH_BACKUP)
# Basic check for statemachine functionality
add_executable(statemachine-init statemachine-init.c)
+add_coverage(statemachine-init)
target_link_libraries(statemachine-init libGammu ${LIBINTL_LIBRARIES})
add_test(statemachine-init "${GAMMU_TEST_PATH}/statemachine-init${CMAKE_EXECUTABLE_SUFFIX}")
# USB device parsing
if (LIBUSB_FOUND AND WITH_NOKIA_SUPPORT)
add_executable(usb-device-parse usb-device-parse.c)
+ add_coverage(usb-device-parse)
target_link_libraries(usb-device-parse libGammu ${LIBINTL_LIBRARIES})
add_test(usb-device-parse "${GAMMU_TEST_PATH}/usb-device-parse${CMAKE_EXECUTABLE_SUFFIX}")
endif (LIBUSB_FOUND AND WITH_NOKIA_SUPPORT)
# Debug testing
add_executable(debug debug.c)
+add_coverage(debug)
target_link_libraries(debug libGammu ${LIBINTL_LIBRARIES})
add_test(debug "${GAMMU_TEST_PATH}/debug${CMAKE_EXECUTABLE_SUFFIX}")
# Check error code descriptions
add_executable(dump-error-codes dump-error-codes.c)
+add_coverage(dump-error-codes)
target_link_libraries(dump-error-codes libGammu ${LIBINTL_LIBRARIES})
add_test(dump-error-codes "${GAMMU_TEST_PATH}/dump-error-codes${CMAKE_EXECUTABLE_SUFFIX}" "-n")
# Check feature code names
add_executable(dump-features dump-features.c)
+add_coverage(dump-features)
target_link_libraries(dump-features libGammu ${LIBINTL_LIBRARIES})
add_test(dump-features "${GAMMU_TEST_PATH}/dump-features${CMAKE_EXECUTABLE_SUFFIX}" "-n")
# Check feature parsing
add_executable(features-parsing features-parsing.c)
+add_coverage(features-parsing)
target_link_libraries(features-parsing libGammu ${LIBINTL_LIBRARIES})
add_test(features-parsing "${GAMMU_TEST_PATH}/features-parsing${CMAKE_EXECUTABLE_SUFFIX}" "-n")
# Check network codes decoding
add_executable(network-codes network-codes.c)
+add_coverage(network-codes)
target_link_libraries(network-codes libGammu ${LIBINTL_LIBRARIES})
add_test(network-codes "${GAMMU_TEST_PATH}/network-codes${CMAKE_EXECUTABLE_SUFFIX}" "-n")
if (WITH_BACKUP)
# smsbackup parsing
add_executable(smsbackup smsbackup.c)
+ add_coverage(smsbackup)
target_link_libraries(smsbackup messagedisplay)
target_link_libraries(smsbackup libGammu ${LIBINTL_LIBRARIES})
@@ -152,6 +169,7 @@ endif (WITH_BACKUP)
if (WITH_BACKUP)
# vCard parsing
add_executable(vcard-read vcard-read.c)
+ add_coverage(vcard-read)
target_link_libraries(vcard-read memorydisplay)
target_link_libraries(vcard-read libGammu ${LIBINTL_LIBRARIES})
@@ -189,6 +207,7 @@ if (WITH_BACKUP)
# LDIF parsing
add_executable(ldif-read ldif-read.c)
+ add_coverage(ldif-read)
target_link_libraries(ldif-read memorydisplay)
target_link_libraries(ldif-read libGammu ${LIBINTL_LIBRARIES})
@@ -212,6 +231,7 @@ endif (WITH_BACKUP)
# [iv]Calendar parsing
if (WITH_BACKUP)
add_executable(cal-read cal-read.c)
+ add_coverage(cal-read)
target_link_libraries(cal-read libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -248,6 +268,7 @@ endif (WITH_BACKUP)
# SMS parsing
if (WITH_NOKIA6110)
add_executable(sms-nokia-01 sms-nokia-01.c)
+ add_coverage(sms-nokia-01)
target_link_libraries(sms-nokia-01 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-01 messagedisplay)
add_test(sms-nokia-01 "${GAMMU_TEST_PATH}/sms-nokia-01${CMAKE_EXECUTABLE_SUFFIX}")
@@ -255,6 +276,7 @@ endif (WITH_NOKIA6110)
if (WITH_NOKIA6510)
add_executable(sms-nokia-02 sms-nokia-02.c)
+ add_coverage(sms-nokia-02)
target_link_libraries(sms-nokia-02 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-02 messagedisplay)
add_test(sms-nokia-02 "${GAMMU_TEST_PATH}/sms-nokia-02${CMAKE_EXECUTABLE_SUFFIX}")
@@ -262,6 +284,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-03 sms-nokia-03.c)
+ add_coverage(sms-nokia-03)
target_link_libraries(sms-nokia-03 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-03 messagedisplay)
add_test(sms-nokia-03 "${GAMMU_TEST_PATH}/sms-nokia-03${CMAKE_EXECUTABLE_SUFFIX}")
@@ -269,6 +292,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-04 sms-nokia-04.c)
+ add_coverage(sms-nokia-04)
target_link_libraries(sms-nokia-04 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-04 messagedisplay)
add_test(sms-nokia-04 "${GAMMU_TEST_PATH}/sms-nokia-04${CMAKE_EXECUTABLE_SUFFIX}")
@@ -276,6 +300,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-05 sms-nokia-05.c)
+ add_coverage(sms-nokia-05)
target_link_libraries(sms-nokia-05 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-05 messagedisplay)
add_test(sms-nokia-05 "${GAMMU_TEST_PATH}/sms-nokia-05${CMAKE_EXECUTABLE_SUFFIX}")
@@ -283,6 +308,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-06 sms-nokia-06.c)
+ add_coverage(sms-nokia-06)
target_link_libraries(sms-nokia-06 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-06 messagedisplay)
add_test(sms-nokia-06 "${GAMMU_TEST_PATH}/sms-nokia-06${CMAKE_EXECUTABLE_SUFFIX}")
@@ -290,12 +316,14 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-07 sms-nokia-07.c)
+ add_coverage(sms-nokia-07)
target_link_libraries(sms-nokia-07 libGammu ${LIBINTL_LIBRARIES})
add_test(sms-nokia-07 "${GAMMU_TEST_PATH}/sms-nokia-07${CMAKE_EXECUTABLE_SUFFIX}")
endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-08 sms-nokia-08.c)
+ add_coverage(sms-nokia-08)
target_link_libraries(sms-nokia-08 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-08 messagedisplay)
add_test(sms-nokia-08 "${GAMMU_TEST_PATH}/sms-nokia-08${CMAKE_EXECUTABLE_SUFFIX}")
@@ -303,6 +331,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-09 sms-nokia-09.c)
+ add_coverage(sms-nokia-09)
target_link_libraries(sms-nokia-09 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-09 messagedisplay)
add_test(sms-nokia-09 "${GAMMU_TEST_PATH}/sms-nokia-09${CMAKE_EXECUTABLE_SUFFIX}")
@@ -310,6 +339,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-10 sms-nokia-10.c)
+ add_coverage(sms-nokia-10)
target_link_libraries(sms-nokia-10 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-10 messagedisplay)
add_test(sms-nokia-10 "${GAMMU_TEST_PATH}/sms-nokia-10${CMAKE_EXECUTABLE_SUFFIX}")
@@ -317,6 +347,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-11 sms-nokia-11.c)
+ add_coverage(sms-nokia-11)
target_link_libraries(sms-nokia-11 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-11 messagedisplay)
add_test(sms-nokia-11 "${GAMMU_TEST_PATH}/sms-nokia-11${CMAKE_EXECUTABLE_SUFFIX}")
@@ -324,6 +355,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-12 sms-nokia-12.c)
+ add_coverage(sms-nokia-12)
target_link_libraries(sms-nokia-12 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-12 messagedisplay)
add_test(sms-nokia-12 "${GAMMU_TEST_PATH}/sms-nokia-12${CMAKE_EXECUTABLE_SUFFIX}")
@@ -331,6 +363,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-13 sms-nokia-13.c)
+ add_coverage(sms-nokia-13)
target_link_libraries(sms-nokia-13 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-13 messagedisplay)
add_test(sms-nokia-13 "${GAMMU_TEST_PATH}/sms-nokia-13${CMAKE_EXECUTABLE_SUFFIX}")
@@ -338,6 +371,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-14 sms-nokia-14.c)
+ add_coverage(sms-nokia-14)
target_link_libraries(sms-nokia-14 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-14 messagedisplay)
add_test(sms-nokia-14 "${GAMMU_TEST_PATH}/sms-nokia-14${CMAKE_EXECUTABLE_SUFFIX}")
@@ -345,6 +379,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-15 sms-nokia-15.c)
+ add_coverage(sms-nokia-15)
target_link_libraries(sms-nokia-15 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-15 messagedisplay)
add_test(sms-nokia-15 "${GAMMU_TEST_PATH}/sms-nokia-15${CMAKE_EXECUTABLE_SUFFIX}")
@@ -352,6 +387,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-16 sms-nokia-16.c)
+ add_coverage(sms-nokia-16)
target_link_libraries(sms-nokia-16 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-16 messagedisplay)
add_test(sms-nokia-16 "${GAMMU_TEST_PATH}/sms-nokia-16${CMAKE_EXECUTABLE_SUFFIX}")
@@ -359,6 +395,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-17 sms-nokia-17.c)
+ add_coverage(sms-nokia-17)
target_link_libraries(sms-nokia-17 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-17 messagedisplay)
add_test(sms-nokia-17 "${GAMMU_TEST_PATH}/sms-nokia-17${CMAKE_EXECUTABLE_SUFFIX}")
@@ -366,6 +403,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6510)
add_executable(sms-nokia-18 sms-nokia-18.c)
+ add_coverage(sms-nokia-18)
target_link_libraries(sms-nokia-18 libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-nokia-18 messagedisplay)
add_test(sms-nokia-18 "${GAMMU_TEST_PATH}/sms-nokia-18${CMAKE_EXECUTABLE_SUFFIX}")
@@ -374,6 +412,7 @@ endif (WITH_NOKIA6510)
if (WITH_NOKIA6110)
# Nokia ringtone
add_executable(nokia-6110-ringtone nokia-6110-ringtone.c)
+ add_coverage(nokia-6110-ringtone)
target_link_libraries(nokia-6110-ringtone libGammu ${LIBINTL_LIBRARIES})
add_test(nokia-6110-ringtone "${GAMMU_TEST_PATH}/nokia-6110-ringtone${CMAKE_EXECUTABLE_SUFFIX}")
endif (WITH_NOKIA6110)
@@ -381,6 +420,7 @@ endif (WITH_NOKIA6110)
if (WITH_ATGEN)
# AT SMS parsing
add_executable(sms-at-parse sms-at-parse.c)
+ add_coverage(sms-at-parse)
target_link_libraries(sms-at-parse libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-at-parse messagedisplay)
@@ -453,6 +493,7 @@ if (WITH_ATGEN)
# AT model parsing
add_executable(get-model-at get-model-at.c)
+ add_coverage(get-model-at)
target_link_libraries(get-model-at libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -470,6 +511,7 @@ if (WITH_ATGEN)
# Samsung memory parsing
add_executable(samsung-get-memory samsung-get-memory.c)
+ add_coverage(samsung-get-memory)
target_link_libraries(samsung-get-memory libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(samsung-get-memory memorydisplay)
@@ -488,6 +530,7 @@ if (WITH_ATGEN)
# AT getting of available phone memories
add_executable(at-get-smsmemories at-get-smsmemories.c)
+ add_coverage(at-get-smsmemories)
target_link_libraries(at-get-smsmemories libGammu ${LIBINTL_LIBRARIES})
# List test cases for all memories
@@ -522,6 +565,7 @@ if (WITH_ATGEN)
# AT CNMI parsing
add_executable(at-cnmi-reply at-cnmi-reply.c)
+ add_coverage(at-cnmi-reply)
target_link_libraries(at-cnmi-reply libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -539,6 +583,7 @@ if (WITH_ATGEN)
# AT CCFC parsing
add_executable(at-ccfc-reply at-ccfc-reply.c)
+ add_coverage(at-ccfc-reply)
target_link_libraries(at-ccfc-reply libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -556,6 +601,7 @@ if (WITH_ATGEN)
# AT CREG parsing
add_executable(at-creg-reply at-creg-reply.c)
+ add_coverage(at-creg-reply)
target_link_libraries(at-creg-reply libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -573,6 +619,7 @@ if (WITH_ATGEN)
# AT memory parsing
add_executable(at-getmemory-reply at-getmemory-reply.c)
+ add_coverage(at-getmemory-reply)
target_link_libraries(at-getmemory-reply libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(at-getmemory-reply memorydisplay)
@@ -597,6 +644,7 @@ if (WITH_ATGEN)
# AT USSD replies parsing
add_executable(at-ussd-reply at-ussd-reply.c)
+ add_coverage(at-ussd-reply)
target_link_libraries(at-ussd-reply libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -611,10 +659,13 @@ if (WITH_ATGEN)
add_test("at-ussd-reply-${TESTNAME}"
"${GAMMU_TEST_PATH}/at-ussd-reply${CMAKE_EXECUTABLE_SUFFIX}"
"${Gammu_SOURCE_DIR}/tests/at-ussd/${TESTMESSAGE}" "${PHONE_MODEL}")
+ set_tests_properties("at-ussd-reply-${TESTNAME}"
+ PROPERTIES FAIL_REGULAR_EXPRESSION "Response: \n")
endforeach(TESTMESSAGE $MESSAGES)
# AT SMSC parsing
add_executable(get-smsc-at get-smsc-at.c)
+ add_coverage(get-smsc-at)
target_link_libraries(get-smsc-at libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -648,6 +699,7 @@ if (WITH_ATGEN)
if (WITH_BACKUP)
# AT SMS encoding
add_executable(sms-at-encode sms-at-encode.c)
+ add_coverage(sms-at-encode)
target_link_libraries(sms-at-encode libGammu ${LIBINTL_LIBRARIES})
# List test cases
@@ -670,6 +722,7 @@ endif (WITH_ATGEN)
if (WITH_OBEXGEN)
# OBEX entries splitting
add_executable(obex-vcard-split obex-vcard-split.c)
+ add_coverage(obex-vcard-split)
target_link_libraries(obex-vcard-split libGammu ${LIBINTL_LIBRARIES})
# Tests
@@ -682,12 +735,14 @@ endif (WITH_OBEXGEN)
# SMS encoding
add_executable(sms-encode-decode sms-encode-decode.c)
+add_coverage(sms-encode-decode)
target_link_libraries(sms-encode-decode libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-encode-decode messagedisplay)
add_test(sms-encode-decode "${GAMMU_TEST_PATH}/sms-encode-decode${CMAKE_EXECUTABLE_SUFFIX}")
# SMS encoding from commandline
add_executable(sms-cmdline sms-cmdline.c)
+add_coverage(sms-cmdline)
target_link_libraries(sms-cmdline libGammu ${LIBINTL_LIBRARIES})
target_link_libraries(sms-cmdline messagedisplay)
target_link_libraries(sms-cmdline messagecmdline)
@@ -787,12 +842,12 @@ set_tests_properties(sms-cmdline-RINGTONE PROPERTIES
PASS_REGULAR_EXPRESSION "Ringtone \"AxelF\"")
add_test(sms-cmdline-MMS "${GAMMU_TEST_PATH}/sms-cmdline${CMAKE_EXECUTABLE_SUFFIX}"
- MMSINDICATOR 800123456 http://wammu.eu/ Wammu Gammu)
+ MMSINDICATOR 800123456 https://wammu.eu/ Wammu Gammu)
set_tests_properties(sms-cmdline-MMS PROPERTIES
PASS_REGULAR_EXPRESSION "User Data Header : MMS indicator, ID \\(8 bit\\) [0-9]*, part 1 of 1")
add_test(sms-cmdline-WAP "${GAMMU_TEST_PATH}/sms-cmdline${CMAKE_EXECUTABLE_SUFFIX}"
- WAPINDICATOR 800123456 http://wammu.eu/ Wammu)
+ WAPINDICATOR 800123456 https://wammu.eu/ Wammu)
set_tests_properties(sms-cmdline-WAP PROPERTIES
PASS_REGULAR_EXPRESSION "User Data Header : MMS indicator, ID \\(8 bit\\) [0-9]*, part 1 of 1")
@@ -872,37 +927,50 @@ endif (WITH_BACKUP)
if (WITH_ATGEN)
# Samsung parser tests
add_executable(at-samsung at-samsung.c)
+ add_coverage(at-samsung)
target_link_libraries(at-samsung libGammu ${LIBINTL_LIBRARIES})
add_test(at-samsung "${GAMMU_TEST_PATH}/at-samsung${CMAKE_EXECUTABLE_SUFFIX}")
# Motorola parser tests
add_executable(at-motorola at-motorola.c)
+ add_coverage(at-motorola)
target_link_libraries(at-motorola libGammu ${LIBINTL_LIBRARIES})
add_test(at-motorola "${GAMMU_TEST_PATH}/at-motorola${CMAKE_EXECUTABLE_SUFFIX}")
# AT parser tests
add_executable(at-parser at-parser.c)
+ add_coverage(at-parser)
target_link_libraries(at-parser libGammu ${LIBINTL_LIBRARIES})
add_test(at-parser "${GAMMU_TEST_PATH}/at-parser${CMAKE_EXECUTABLE_SUFFIX}")
# AT dispatch tests
add_executable(at-dispatch at-dispatch.c)
+ add_coverage(at-dispatch)
target_link_libraries(at-dispatch libGammu ${LIBINTL_LIBRARIES})
add_test(at-dispatch "${GAMMU_TEST_PATH}/at-dispatch${CMAKE_EXECUTABLE_SUFFIX}")
# AT text encoding/decoding
add_executable(at-charset at-charset.c)
+ add_coverage(at-charset)
target_link_libraries(at-charset libGammu ${LIBINTL_LIBRARIES})
add_test(at-charset "${GAMMU_TEST_PATH}/at-charset${CMAKE_EXECUTABLE_SUFFIX}")
+
+ # AT statemachine
+ add_executable(at-statemachine at-statemachine.c)
+ add_coverage(at-statemachine)
+ target_link_libraries(at-statemachine libGammu ${LIBINTL_LIBRARIES})
+ add_test(at-statemachine "${GAMMU_TEST_PATH}/at-statemachine${CMAKE_EXECUTABLE_SUFFIX}")
endif (WITH_ATGEN)
# Line parser tests
add_executable(line-splitting line-splitting.c)
+add_coverage(line-splitting)
target_link_libraries(line-splitting libGammu ${LIBINTL_LIBRARIES})
add_test(line-splitting "${GAMMU_TEST_PATH}/line-splitting${CMAKE_EXECUTABLE_SUFFIX}")
# Config file parsing
add_executable(config config.c)
+add_coverage(config)
target_link_libraries(config libGammu ${LIBINTL_LIBRARIES})
file(GLOB CONFIGS
RELATIVE "${Gammu_SOURCE_DIR}/tests/configs"
@@ -918,6 +986,7 @@ endforeach(TESTCONFIG $CONFIGS)
# INI file parsing
add_executable(inifile inifile.c)
+add_coverage(inifile)
target_link_libraries(inifile libGammu ${LIBINTL_LIBRARIES})
file(GLOB INIFILES
RELATIVE "${Gammu_SOURCE_DIR}/tests/inifiles"
@@ -930,16 +999,22 @@ endforeach(TESTINIFILE $INIFILES)
# Examples
add_executable(phone-info "${Gammu_SOURCE_DIR}/docs/examples/phone-info.c")
+add_coverage(phone-info)
target_link_libraries(phone-info libGammu ${LIBINTL_LIBRARIES})
add_executable(custom-config "${Gammu_SOURCE_DIR}/docs/examples/custom-config.c")
+add_coverage(custom-config)
target_link_libraries(custom-config libGammu ${LIBINTL_LIBRARIES})
add_executable(sms-send "${Gammu_SOURCE_DIR}/docs/examples/sms-send.c")
+add_coverage(sms-send)
target_link_libraries(sms-send libGammu ${LIBINTL_LIBRARIES})
add_executable(long-sms "${Gammu_SOURCE_DIR}/docs/examples/long-sms.c")
+add_coverage(long-sms)
target_link_libraries(long-sms libGammu ${LIBINTL_LIBRARIES})
add_executable(sms-read "${Gammu_SOURCE_DIR}/docs/examples/sms-read.c")
+add_coverage(sms-read)
target_link_libraries(sms-read libGammu ${LIBINTL_LIBRARIES})
add_executable(smsd "${Gammu_SOURCE_DIR}/docs/examples/smsd.c")
+add_coverage(smsd)
target_link_libraries(smsd libGammu ${LIBINTL_LIBRARIES} gsmsd)
# Examples tests, works with dummy phone
@@ -957,131 +1032,157 @@ endif (WITH_BACKUP)
# Test for header gammu-backup.h
add_executable(include-backup include-backup.c)
+add_coverage(include-backup)
target_link_libraries(include-backup libGammu ${LIBINTL_LIBRARIES})
add_test(include-backup "${GAMMU_TEST_PATH}/include-backup${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-bitmap.h
add_executable(include-bitmap include-bitmap.c)
+add_coverage(include-bitmap)
target_link_libraries(include-bitmap libGammu ${LIBINTL_LIBRARIES})
add_test(include-bitmap "${GAMMU_TEST_PATH}/include-bitmap${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-calendar.h
add_executable(include-calendar include-calendar.c)
+add_coverage(include-calendar)
target_link_libraries(include-calendar libGammu ${LIBINTL_LIBRARIES})
add_test(include-calendar "${GAMMU_TEST_PATH}/include-calendar${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-callback.h
add_executable(include-callback include-callback.c)
+add_coverage(include-callback)
target_link_libraries(include-callback libGammu ${LIBINTL_LIBRARIES})
add_test(include-callback "${GAMMU_TEST_PATH}/include-callback${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-call.h
add_executable(include-call include-call.c)
+add_coverage(include-call)
target_link_libraries(include-call libGammu ${LIBINTL_LIBRARIES})
add_test(include-call "${GAMMU_TEST_PATH}/include-call${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-category.h
add_executable(include-category include-category.c)
+add_coverage(include-category)
target_link_libraries(include-category libGammu ${LIBINTL_LIBRARIES})
add_test(include-category "${GAMMU_TEST_PATH}/include-category${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-datetime.h
add_executable(include-datetime include-datetime.c)
+add_coverage(include-datetime)
target_link_libraries(include-datetime libGammu ${LIBINTL_LIBRARIES})
add_test(include-datetime "${GAMMU_TEST_PATH}/include-datetime${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-debug.h
add_executable(include-debug include-debug.c)
+add_coverage(include-debug)
target_link_libraries(include-debug libGammu ${LIBINTL_LIBRARIES})
add_test(include-debug "${GAMMU_TEST_PATH}/include-debug${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-error.h
add_executable(include-error include-error.c)
+add_coverage(include-error)
target_link_libraries(include-error libGammu ${LIBINTL_LIBRARIES})
add_test(include-error "${GAMMU_TEST_PATH}/include-error${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-file.h
add_executable(include-file include-file.c)
+add_coverage(include-file)
target_link_libraries(include-file libGammu ${LIBINTL_LIBRARIES})
add_test(include-file "${GAMMU_TEST_PATH}/include-file${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-info.h
add_executable(include-info include-info.c)
+add_coverage(include-info)
target_link_libraries(include-info libGammu ${LIBINTL_LIBRARIES})
add_test(include-info "${GAMMU_TEST_PATH}/include-info${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-inifile.h
add_executable(include-inifile include-inifile.c)
+add_coverage(include-inifile)
target_link_libraries(include-inifile libGammu ${LIBINTL_LIBRARIES})
add_test(include-inifile "${GAMMU_TEST_PATH}/include-inifile${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-keys.h
add_executable(include-keys include-keys.c)
+add_coverage(include-keys)
target_link_libraries(include-keys libGammu ${LIBINTL_LIBRARIES})
add_test(include-keys "${GAMMU_TEST_PATH}/include-keys${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-limits.h
add_executable(include-limits include-limits.c)
+add_coverage(include-limits)
target_link_libraries(include-limits libGammu ${LIBINTL_LIBRARIES})
add_test(include-limits "${GAMMU_TEST_PATH}/include-limits${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-memory.h
add_executable(include-memory include-memory.c)
+add_coverage(include-memory)
target_link_libraries(include-memory libGammu ${LIBINTL_LIBRARIES})
add_test(include-memory "${GAMMU_TEST_PATH}/include-memory${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-message.h
add_executable(include-message include-message.c)
+add_coverage(include-message)
target_link_libraries(include-message libGammu ${LIBINTL_LIBRARIES})
add_test(include-message "${GAMMU_TEST_PATH}/include-message${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-misc.h
add_executable(include-misc include-misc.c)
+add_coverage(include-misc)
target_link_libraries(include-misc libGammu ${LIBINTL_LIBRARIES})
add_test(include-misc "${GAMMU_TEST_PATH}/include-misc${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-nokia.h
add_executable(include-nokia include-nokia.c)
+add_coverage(include-nokia)
target_link_libraries(include-nokia libGammu ${LIBINTL_LIBRARIES})
add_test(include-nokia "${GAMMU_TEST_PATH}/include-nokia${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-ringtone.h
add_executable(include-ringtone include-ringtone.c)
+add_coverage(include-ringtone)
target_link_libraries(include-ringtone libGammu ${LIBINTL_LIBRARIES})
add_test(include-ringtone "${GAMMU_TEST_PATH}/include-ringtone${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-security.h
add_executable(include-security include-security.c)
+add_coverage(include-security)
target_link_libraries(include-security libGammu ${LIBINTL_LIBRARIES})
add_test(include-security "${GAMMU_TEST_PATH}/include-security${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-settings.h
add_executable(include-settings include-settings.c)
+add_coverage(include-settings)
target_link_libraries(include-settings libGammu ${LIBINTL_LIBRARIES})
add_test(include-settings "${GAMMU_TEST_PATH}/include-settings${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-smsd.h
add_executable(include-smsd include-smsd.c)
+add_coverage(include-smsd)
target_link_libraries(include-smsd libGammu ${LIBINTL_LIBRARIES})
add_test(include-smsd "${GAMMU_TEST_PATH}/include-smsd${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-statemachine.h
add_executable(include-statemachine include-statemachine.c)
+add_coverage(include-statemachine)
target_link_libraries(include-statemachine libGammu ${LIBINTL_LIBRARIES})
add_test(include-statemachine "${GAMMU_TEST_PATH}/include-statemachine${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-types.h
add_executable(include-types include-types.c)
+add_coverage(include-types)
target_link_libraries(include-types libGammu ${LIBINTL_LIBRARIES})
add_test(include-types "${GAMMU_TEST_PATH}/include-types${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-unicode.h
add_executable(include-unicode include-unicode.c)
+add_coverage(include-unicode)
target_link_libraries(include-unicode libGammu ${LIBINTL_LIBRARIES})
add_test(include-unicode "${GAMMU_TEST_PATH}/include-unicode${CMAKE_EXECUTABLE_SUFFIX}")
# Test for header gammu-wap.h
add_executable(include-wap include-wap.c)
+add_coverage(include-wap)
target_link_libraries(include-wap libGammu ${LIBINTL_LIBRARIES})
add_test(include-wap "${GAMMU_TEST_PATH}/include-wap${CMAKE_EXECUTABLE_SUFFIX}")
@@ -1089,6 +1190,7 @@ add_test(include-wap "${GAMMU_TEST_PATH}/include-wap${CMAKE_EXECUTABLE_SUFFIX}")
# Test for GetInt
add_executable(getint getint.c)
+add_coverage(getint)
target_link_libraries(getint cmdline)
set(GETINT_PASS 1 23213 3213213 -321312 -1)
set(GETINT_FAIL 1a 24432f xxx foo 3243243243243243232432432432432)
@@ -1111,6 +1213,7 @@ if (NOT WIN32)
execute_process(COMMAND test -w /var/lock/ RESULT_VARIABLE VAR_LOCK_WRITABLE)
if (VAR_LOCK_WRITABLE EQUAL 0)
add_executable(locking locking.c)
+ add_coverage(locking)
target_link_libraries(locking libGammu ${LIBINTL_LIBRARIES})
add_test(locking "${GAMMU_TEST_PATH}/locking${CMAKE_EXECUTABLE_SUFFIX}")
else (VAR_LOCK_WRITABLE EQUAL 0)
diff --git a/tests/at-ccfc/ma260.dump b/tests/at-ccfc/ma260.dump
new file mode 100644
index 0000000..76d938d
--- /dev/null
+++ b/tests/at-ccfc/ma260.dump
@@ -0,0 +1,3 @@
+AT+CCFC=4,0
++CCFC: 1,1,"+420123456678",145,,,
+OK
diff --git a/tests/at-statemachine.c b/tests/at-statemachine.c
new file mode 100644
index 0000000..8f23e02
--- /dev/null
+++ b/tests/at-statemachine.c
@@ -0,0 +1,97 @@
+/* Test for decoding SMS on AT driver */
+
+#include <gammu.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "common.h"
+#include "../libgammu/protocol/at/at.h"
+#include "../libgammu/protocol/protocol.h" /* Needed for GSM_Protocol_Message */
+#include "../libgammu/gsmstate.h" /* Needed for state machine internals */
+#include "../libgammu/gsmphones.h" /* Phone data */
+
+static const char *test_data = "+CUSD: 2,\"Maaf, permintaan Anda tidak dapat kami proses. Silakan coba beberapa saat lagi.\",0\r\nAT+CSCS=\"HEX\"\r\nOK\r\n";
+
+static const char *second_test = "+CMTI: \"SM\",1\r\nAT+CPMS=\"SM\",\"SM\"\r\r\n+CPMS: 1,20,1,20,1,20\r\n\r\nOK\r\n";
+
+int main(int argc UNUSED, char **argv UNUSED)
+{
+ GSM_Debug_Info *debug_info;
+ GSM_Phone_ATGENData *Priv;
+ GSM_Phone_Data *Data;
+ GSM_StateMachine *s;
+ GSM_Protocol_ATData *d;
+ size_t i;
+ GSM_Error error;
+
+ /* Configure state machine */
+ debug_info = GSM_GetGlobalDebug();
+ GSM_SetDebugFileDescriptor(stderr, FALSE, debug_info);
+ GSM_SetDebugLevel("textall", debug_info);
+
+ /* Allocates state machine */
+ s = GSM_AllocStateMachine();
+ test_result(s != NULL);
+ debug_info = GSM_GetDebug(s);
+ GSM_SetDebugGlobal(TRUE, debug_info);
+
+ /* Initialize AT engine */
+ Data = &s->Phone.Data;
+ Data->ModelInfo = GetModelData(NULL, NULL, "unknown", NULL);
+ Data->RequestID = ID_SetMemoryCharset;
+ Priv = &s->Phone.Data.Priv.ATGEN;
+ Priv->ReplyState = AT_Reply_OK;
+ Priv->SMSMode = SMS_AT_PDU;
+ Priv->Charset = AT_CHARSET_GSM;
+ s->Phone.Functions = &ATGENPhone;
+
+ d = &s->Protocol.Data.AT;
+ d->Msg.Buffer = NULL;
+ d->Msg.BufferUsed = 0;
+ d->Msg.Length = 0;
+ d->Msg.Type = 0;
+ d->SpecialAnswerLines = 0;
+ d->LineStart = -1;
+ d->LineEnd = -1;
+ d->wascrlf = FALSE;
+ d->EditMode = FALSE;
+ d->FastWrite = FALSE;
+ d->CPINNoOK = FALSE;
+
+ /* Feed data */
+ for (i = 0; i < strlen(test_data); i++) {
+ error = AT_StateMachine(s, test_data[i]);
+ gammu_test_result(error, "AT_StateMachine");
+ }
+
+ test_result(s->MessagesCount == 2);
+
+ Data->RequestID = ID_SetMemoryType;
+
+ /* Feed data */
+ for (i = 0; i < strlen(second_test); i++) {
+ error = AT_StateMachine(s, second_test[i]);
+ gammu_test_result(error, "AT_StateMachine");
+ }
+
+ test_result(s->MessagesCount == 4);
+
+ Data->RequestID = ID_None;
+
+ /* Feed data */
+ for (i = 0; i < strlen(second_test); i++) {
+ error = AT_StateMachine(s, second_test[i]);
+ gammu_test_result(error, "AT_StateMachine");
+ }
+
+ test_result(s->MessagesCount == 6);
+
+ /* Free state machine */
+ GSM_FreeStateMachine(s);
+
+ return 0;
+}
+
+/* Editor configuration
+ * vim: noexpandtab sw=8 ts=8 sts=8 tw=72:
+ */
diff --git a/tests/at-ussd/04-unknown.dump b/tests/at-ussd/04-unknown.dump
new file mode 100644
index 0000000..3e84f7d
--- /dev/null
+++ b/tests/at-ussd/04-unknown.dump
@@ -0,0 +1 @@
++CUSD: 2,"Maaf, permintaan Anda tidak dapat kami proses. Silakan coba beberapa saat lagi.",0
diff --git a/tests/at-ussd/issue178-dell.dump b/tests/at-ussd/issue178-dell.dump
new file mode 100644
index 0000000..d506cb1
--- /dev/null
+++ b/tests/at-ussd/issue178-dell.dump
@@ -0,0 +1,2 @@
++CUSD: 0,"On DATA Pack u have 3Gb 817Mb 169kb valid until 21/05/2016 upto time of data recharge done by u.",15
+
diff --git a/tests/gen-include-test.sh b/tests/gen-include-test.sh
index c886500..b187f99 100755
--- a/tests/gen-include-test.sh
+++ b/tests/gen-include-test.sh
@@ -38,7 +38,7 @@ for x in `ls ../include/ | grep -v gammu.h | grep -v CMake` ; do
echo "#endif"
echo
echo "int main(int argc UNUSED, char **argv UNUSED)"
- echo "{"
+ echo "{"
echo " return 0;"
echo "}"
) > $filename
@@ -47,6 +47,7 @@ for x in `ls ../include/ | grep -v gammu.h | grep -v CMake` ; do
cecho
cecho "# Test for header $x"
cecho "add_executable($executable $filename)"
+ cecho "add_coverage($executable)"
cecho "target_link_libraries($executable libGammu \${LIBINTL_LIBRARIES})"
cecho "add_test($executable \"\${GAMMU_TEST_PATH}/$executable\${CMAKE_EXECUTABLE_SUFFIX}\")"
diff --git a/tests/misc/wap-bookmark.backup b/tests/misc/wap-bookmark.backup
index 961c952..b1a9d15 100644
--- a/tests/misc/wap-bookmark.backup
+++ b/tests/misc/wap-bookmark.backup
@@ -3,5 +3,5 @@ Creator = "GVIM"
Format = 1.04
[WAPBookmark00]
-URL = http://wammu.eu/
+URL = https://wammu.eu/
Title = Wammu
diff --git a/tests/odbc.ini b/tests/odbc.ini
new file mode 100644
index 0000000..cf71523
--- /dev/null
+++ b/tests/odbc.ini
@@ -0,0 +1,7 @@
+[ODBCTest]
+Driver = MySQL
+USER = root
+PASSWORD =
+Server = localhost
+Database = smsd
+Port = 3306
diff --git a/tests/sms-at-encode.c b/tests/sms-at-encode.c
index d41357c..2365d89 100644
--- a/tests/sms-at-encode.c
+++ b/tests/sms-at-encode.c
@@ -10,7 +10,7 @@
#include "common.h"
-extern GSM_Error ATGEN_MakeSMSFrame(GSM_StateMachine *s, GSM_SMSMessage *message, unsigned char *hexreq, int *current, size_t *length2);
+extern GSM_Error ATGEN_MakeSMSFrame(GSM_StateMachine *s, GSM_SMSMessage *message, unsigned char *hexreq, size_t hexlength, int *current, size_t *length2);
#define BUFFER_SIZE 16384
@@ -27,9 +27,14 @@ int main(int argc, char **argv)
int current;
size_t current2;
unsigned char hexreq[1000];
- GSM_SMS_Backup Backup;
+ GSM_SMS_Backup *Backup;
gboolean generate = FALSE;
+ Backup = malloc(sizeof(GSM_SMS_Backup));
+ if (Backup == NULL) {
+ return 99;
+ }
+
/* Enable debugging */
debug_info = GSM_GetGlobalDebug();
GSM_SetDebugFileDescriptor(stderr, FALSE, debug_info);
@@ -47,7 +52,7 @@ int main(int argc, char **argv)
}
/* Read message */
- error = GSM_ReadSMSBackupFile(argv[1], &Backup);
+ error = GSM_ReadSMSBackupFile(argv[1], Backup);
gammu_test_result(error, "GSM_ReadSMSBackupFile");
if (!generate) {
@@ -94,11 +99,11 @@ int main(int argc, char **argv)
Priv->SIMSMSMemory = AT_AVAILABLE;
/* Format SMS frame */
- error = ATGEN_MakeSMSFrame(s, Backup.SMS[0], hexreq, &current, &current2);
+ error = ATGEN_MakeSMSFrame(s, Backup->SMS[0], hexreq, sizeof(hexreq), &current, &current2);
gammu_test_result(error, "ATGEN_MakeSMSFrame");
/* We don't need this anymore */
- GSM_FreeSMSBackup(&Backup);
+ GSM_FreeSMSBackup(Backup);
/* Display message */
if (generate) {
diff --git a/tests/smsbackup.c b/tests/smsbackup.c
index a9944d2..9f8e9fc 100644
--- a/tests/smsbackup.c
+++ b/tests/smsbackup.c
@@ -14,7 +14,7 @@ int main(int argc UNUSED, char **argv UNUSED)
{
GSM_Debug_Info *debug_info;
GSM_Error error;
- GSM_SMS_Backup Backup;
+ GSM_SMS_Backup *Backup;
GSM_MultiSMSMessage **SortedSMS, **InputSMS;
int i, count;
@@ -28,13 +28,18 @@ int main(int argc UNUSED, char **argv UNUSED)
GSM_SetDebugFileDescriptor(stderr, FALSE, debug_info);
GSM_SetDebugLevel("textall", debug_info);
+ Backup = malloc(sizeof(GSM_SMS_Backup));
+ if (Backup == NULL) {
+ return 99;
+ }
+
/* Read the backup */
- error = GSM_ReadSMSBackupFile(argv[1], &Backup);
+ error = GSM_ReadSMSBackupFile(argv[1], Backup);
gammu_test_result(error, "GSM_ReadSMSBackupFile");
/* Calculate number of messages */
count = 0;
- while (Backup.SMS[count] != NULL) {
+ while (Backup->SMS[count] != NULL) {
count++;
}
@@ -46,7 +51,7 @@ int main(int argc UNUSED, char **argv UNUSED)
for (i = 0; i < count; i++) {
InputSMS[i] = (GSM_MultiSMSMessage *) malloc(sizeof(GSM_MultiSMSMessage));
InputSMS[i]->Number = 1;
- InputSMS[i]->SMS[0] = *Backup.SMS[i];
+ InputSMS[i]->SMS[0] = *(Backup->SMS[i]);
}
InputSMS[i] = NULL;
@@ -66,7 +71,7 @@ int main(int argc UNUSED, char **argv UNUSED)
}
/* We don't need this anymore */
- GSM_FreeSMSBackup(&Backup);
+ GSM_FreeSMSBackup(Backup);
free(InputSMS);
free(SortedSMS);