diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/CMakeLists.txt | 107 | ||||
| -rw-r--r-- | tests/at-ccfc/ma260.dump | 3 | ||||
| -rw-r--r-- | tests/at-statemachine.c | 97 | ||||
| -rw-r--r-- | tests/at-ussd/04-unknown.dump | 1 | ||||
| -rw-r--r-- | tests/at-ussd/issue178-dell.dump | 2 | ||||
| -rwxr-xr-x | tests/gen-include-test.sh | 3 | ||||
| -rw-r--r-- | tests/misc/wap-bookmark.backup | 2 | ||||
| -rw-r--r-- | tests/odbc.ini | 7 | ||||
| -rw-r--r-- | tests/sms-at-encode.c | 15 | ||||
| -rw-r--r-- | tests/smsbackup.c | 15 |
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, ¤t, ¤t2); + error = ATGEN_MakeSMSFrame(s, Backup->SMS[0], hexreq, sizeof(hexreq), ¤t, ¤t2); 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); |