diff options
Diffstat (limited to 'debian/pilot-link/pilot-link-0.12.5-dfsg/tests/dlp-test.c')
| -rw-r--r-- | debian/pilot-link/pilot-link-0.12.5-dfsg/tests/dlp-test.c | 724 |
1 files changed, 724 insertions, 0 deletions
diff --git a/debian/pilot-link/pilot-link-0.12.5-dfsg/tests/dlp-test.c b/debian/pilot-link/pilot-link-0.12.5-dfsg/tests/dlp-test.c new file mode 100644 index 00000000..45924f60 --- /dev/null +++ b/debian/pilot-link/pilot-link-0.12.5-dfsg/tests/dlp-test.c @@ -0,0 +1,724 @@ +/* + * dlp-test.c: DLP Regression Test + * + * (c) 2002, JP Rosevear. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General + * Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * + * This regression test calls every DLP function except the following: + * dlp_CallApplication + * dlp_ResetSystem + * dlp_ProcessRPC + */ + +#include <stdio.h> + +#include "pi-debug.h" +#include "pi-source.h" +#include "pi-dlp.h" + +/* Prototypes */ +int pilot_connect(char *port); + +/* For various protocol versions, set to 0 to not test those versions */ +#define DLP_1_1 1 +#define DLP_1_2 1 + +/* Logging defines */ +#define CHECK_RESULT(func) \ + if (result < 0) { \ + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST " #func " failed (%d)\n", result)); \ + goto error; \ + } + +/* Utility defines */ +#define pi_mktag(c1,c2,c3,c4) (((c1)<<24)|((c2)<<16)|((c3)<<8)|(c4)) + +#define CREATOR pi_mktag('T', 'e', 's', 't') +#define DATA pi_mktag('D', 'A', 'T', 'A') +#define INFO pi_mktag('I', 'N', 'F', 'O') + +int +main (int argc, char **argv) +{ + int sd; + int result; + struct SysInfo s; + struct PilotUser u1, u2; + struct NetSyncInfo n1, n2; + struct CardInfo c; + struct DBInfo dbi; + struct DBSizeInfo dbsi; + unsigned long romVersion; + time_t t1, t2; + int handle; + unsigned char pref1[256], pref2[256]; + unsigned char ablock1[256]; + unsigned char sblock1[256]; + unsigned char ires1[256]; + unsigned char dres1[256]; + unsigned char record1[256], record2[256], record3[256]; + recordid_t rid1, rid2, rid3, rlist[4]; + int index, id_, count; + unsigned long type; + int cardno; + int i; + pi_buffer_t *record4, + *dres2, + *ires2, + *appblock; + + record4 = pi_buffer_new (sizeof(record1)); + ires2 = pi_buffer_new (sizeof (ires1)); + dres2 = pi_buffer_new (sizeof (dres1)); + appblock = pi_buffer_new(256); + + sd = pilot_connect (argv[1]); + + t1 = time (NULL); + LOG((PI_DBG_USER, PI_DBG_LVL_INFO, "DLPTEST Starting at %s", ctime (&t1))); + + /********************************************************************* + * + * Test: Open Conduit + * + * Direct Testing Functions: + * dlp_OpenConduit + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_OpenConduit (sd); + CHECK_RESULT(dlp_OpenConduit); + + /********************************************************************* + * + * Test: System Information + * + * Direct Testing Functions: + * dlp_ReadSysInfo + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_ReadSysInfo (sd, &s); + CHECK_RESULT(dlp_ReadSysInfo); + + /********************************************************************* + * + * Test: User Info + * + * Direct Testing Functions: + * dlp_WriteUserInfo + * dlp_ReadUserInfo + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + memset (&u1, '\0', sizeof (struct PilotUser)); + memset (&u2, '\0', sizeof (struct PilotUser)); + u1.passwordLength = 0; + strcpy (u1.username, "Test User"); + strcpy (u1.password, ""); + u1.userID = 500; + u1.viewerID = 5000; + u1.lastSyncPC = 111111; + u1.successfulSyncDate = time(NULL); + u1.lastSyncDate = time(NULL) + 100; + + result = dlp_WriteUserInfo (sd, &u1); + CHECK_RESULT(dlp_WriteUserInfo); + result = dlp_ReadUserInfo (sd, &u2); + CHECK_RESULT(dlp_ReadUserInfo); + if (memcmp(&u1, &u2, sizeof(struct PilotUser) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST User info mismatch\n")); + goto error; + } + + /********************************************************************* + * + * Test: Feature + * + * Direct Testing Functions: + * dlp_ReadFeature + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + romVersion = 0; + + result = dlp_ReadFeature(sd, makelong("psys"), 1, &romVersion); + CHECK_RESULT(dlp_ReadFeature); + if (romVersion != s.romVersion) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Rom Version mismatch\n")); + goto error; + } + + /********************************************************************* + * + * Test: Net Sync Info + * + * Direct Testing Functions: + * dlp_WriteNetSyncInfo + * dlp_ReadNetSyncInfo + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ +#if DLP_1_1 + memset (&n1, '\0', sizeof (struct NetSyncInfo)); + memset (&n2, '\0', sizeof (struct NetSyncInfo)); + n1.lanSync = 0; + strcpy (n1.hostName, "localhost"); + strcpy (n1.hostAddress, "192.168.1.1"); + strcpy (n1.hostSubnetMask, "255.255.255.0"); + + result = dlp_WriteNetSyncInfo (sd, &n1); + CHECK_RESULT(dlp_WriteNetSyncInfo); + result = dlp_ReadNetSyncInfo (sd, &n2); + CHECK_RESULT(dlp_ReadNetSyncInfo); + if (memcmp(&n1, &n2, sizeof(struct NetSyncInfo) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Net sync info mismatch\n")); + goto error; + } +#endif + + /********************************************************************* + * + * Test: Time + * + * Direct Testing Functions: + * dlp_SetSysDateTime + * dlp_GetSysDateTime + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + t1 = time(NULL); + + dlp_SetSysDateTime (sd, t1); + CHECK_RESULT(dlp_SetSysDateTime); + dlp_GetSysDateTime (sd, &t2); + CHECK_RESULT(dlp_GetSysDateTime); + if (t2 > t1 + 1) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST System Time Mismatch\n")); + goto error; + } + + /********************************************************************* + * + * Test: Storage Information + * + * Direct Testing Functions: + * dlp_ReadStorageInfo + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + c.more = 1; + for (i = 0; c.more != 0; i++) { + result = dlp_ReadStorageInfo (sd, i, &c); + CHECK_RESULT(dlp_ReadStorageInfo); + } + + /********************************************************************* + * + * Test: Database List + * + * Direct Testing Functions: + * dlp_ReadDBList + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + dbi.more = 1; + for (i = 0; dbi.more != 0; i++) { + result = dlp_ReadDBList (sd, 0, dlpDBListRAM | dlpDBListROM, i, record4); + CHECK_RESULT(dlp_ReadDBList); + memcpy(&dbi, record4->data, sizeof(struct DBInfo)); + } + + /********************************************************************* + * + * Test: Existing Database + * + * Direct Testing Functions: + * dlp_OpenDB + * dlp_CloseDB + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "ToDoDB", &handle); + CHECK_RESULT(dlp_OpenDB); + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + + /********************************************************************* + * + * Test: New Database + * + * Direct Testing Functions: + * dlp_CreateDB + * dlp_CloseDB + * dlp_DeleteDB + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_CreateDB (sd, CREATOR, DATA, 0, dlpDBFlagResource, 1, "TestResource", &handle); + CHECK_RESULT(dlp_CreateDB); + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + result = dlp_DeleteDB (sd, 0, "TestResource"); + CHECK_RESULT(dlp_DeleteDB); + + /********************************************************************* + * + * Test: Database Info and Searching + * + * Direct Testing Functions: + * dlp_SetDBInfo + * dlp_FindDBByName + * dlp_FindDBByOpenHandle + * dlp_FindDBByTypeCreator + * + * Indirect Testing Functions: + * dlp_CreateDB + * dlp_OpenDB + * dlp_ReadDBList + * dlp_CloseDB + * dlp_DeleteDB + * + *********************************************************************/ +#if DLP_1_2 + result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle); + CHECK_RESULT(dlp_CreateDB); + result = dlp_SetDBInfo (sd, handle, dlpDBFlagBackup, dlpDBFlagCopyPrevention, 0, 0, 0, 0, 0, 0); + CHECK_RESULT(dlp_SetDBInfo); + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + + result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "TestRecord", &handle); + CHECK_RESULT(dlp_OpenDB); + + result = dlp_FindDBByOpenHandle (sd, handle, &cardno, NULL, &dbi, &dbsi); + CHECK_RESULT(dlp_FindDBByOpenHandle); + if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with openhandle\n")); + goto error; + } + + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + + result = dlp_FindDBByName (sd, 0, "TestRecord", NULL, NULL, &dbi, &dbsi); + CHECK_RESULT(dlp_FindDBByName); + if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with name\n")); + goto error; + } + + result = dlp_FindDBByTypeCreator (sd, DATA, CREATOR, 1, 0, &cardno, NULL, NULL, &dbi, &dbsi); + CHECK_RESULT(dlp_FindDBByName); + if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with type/creator\n")); + goto error; + } + + result = dlp_DeleteDB (sd, 0, "TestRecord"); + CHECK_RESULT(dlp_DeleteDB); +#endif + + /********************************************************************* + * + * Test: App Preference + * + * Direct Testing Functions: + * dlp_WriteAppPreference + * dlp_ReadAppPreference + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + memset (pref1, '\0', sizeof (pref1)); + memset (pref2, '\0', sizeof (pref2)); + pref1[9] = 'T'; + pref2[10] = 'T'; + + result = dlp_WriteAppPreference (sd, CREATOR, 0, 1, 1, pref1, sizeof(pref1)); + CHECK_RESULT(dlp_WriteAppPrefence); + result = dlp_ReadAppPreference (sd, CREATOR, 0, 1, sizeof(pref2), pref2, NULL, NULL); + CHECK_RESULT(dlp_ReadAppPreference); + if (memcmp(&pref1, &pref2, sizeof(pref1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Preference mismatch\n")); + goto error; + } + + /********************************************************************* + * + * Test: Record + * + * Direct Testing Functions: + * dlp_WriteAppBlock + * dlp_ReadAppBlock + * dlp_WriteSortBlock + * dlp_ReadSortBlock + * dlp_WriteRecord + * dlp_ReadOpenDBInfo + * dlp_ReadRecordById + * dlp_ReadRecordByIndex + * dlp_ReadNextModifiedRec + * dlp_ReadNextRecInCategory + * dlp_ReadNextModifiedRecInCategory + * dlp_MoveCategory + * dlp_DeleteRecord + * dlp_DeleteCategory + * dlp_ResetDBIndex + * + * Indirect Testing Functions: + * dlp_CreateDB + * dlp_CloseDB + * dlp_DeleteDB + * + *********************************************************************/ + memset (ablock1, '\0', sizeof (ablock1)); + memset (sblock1, '\0', sizeof (sblock1)); + memset (record1, '\0', sizeof (record1)); + memset (record2, '\0', sizeof (record2)); + memset (record3, '\0', sizeof (record3)); + ablock1[3] = 'T'; + sblock1[17] = 'T'; + record1[32] = 'T'; + record2[33] = 'T'; + record3[34] = 'T'; + + result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle); + CHECK_RESULT(dlp_CreateDB); + + /* Write and read back an app block */ + result = dlp_WriteAppBlock (sd, handle, ablock1, sizeof(ablock1)); + CHECK_RESULT(dlp_WriteAppBlock); + result = dlp_ReadAppBlock (sd, handle, 0, sizeof(ablock1), appblock); + CHECK_RESULT(dlp_ReadAppBlock); + if (result != sizeof(ablock1) || memcmp(ablock1, appblock->data, sizeof(ablock1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST App block mismatch\n")); + goto error; + } + + /* Write and read back a sort block */ + result = dlp_WriteSortBlock (sd, handle, sblock1, sizeof(sblock1)); + CHECK_RESULT(dlp_WriteSortBlock); + result = dlp_ReadSortBlock (sd, handle, 0, sizeof(sblock1), appblock); + CHECK_RESULT(dlp_ReadSortBlock); + if (result != sizeof(sblock1) || memcmp(sblock1, appblock->data, sizeof(sblock1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST App block mismatch\n")); + goto error; + } + + /* Write some records out */ + result = dlp_WriteRecord (sd, handle, 0, 0, 1, record1, sizeof(record1), &rid1); + CHECK_RESULT(dlp_WriteRecord); + result = dlp_WriteRecord (sd, handle, dlpRecAttrDirty, 0, 2, record2, sizeof(record2), &rid2); + CHECK_RESULT(dlp_WriteRecord); + result = dlp_WriteRecord (sd, handle, 0, 0, 3, record3, sizeof(record3), &rid3); + CHECK_RESULT(dlp_WriteRecord); + + /* Get the db info */ + result = dlp_ReadOpenDBInfo (sd, handle, &count); + CHECK_RESULT(dlp_ReadOpenDBInfo); + if (count != 3) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong open database info\n")); + goto error; + } + + /* Get the id list */ + result = dlp_ReadRecordIDList (sd, handle, 0, 0, 4, rlist, &count); + CHECK_RESULT(dlp_ReadRecordIDList); + if (count != 3) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong record id list length\n")); + goto error; + } + for (i = 0; i < 3; i++) { + if (rlist[i] != rid1 && rlist[i] != rid2 && rlist[i] != rid3) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong record id\n")); + goto error; + } + } + + /* Try reading the records in various ways */ + result = dlp_ReadRecordById (sd, handle, rid1, record4, &index, NULL, NULL); + CHECK_RESULT(dlp_ReadRecordById); + if (memcmp(record1, record4->data, sizeof(record1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Record by Id mismatch\n")); + goto error; + } + result = dlp_ReadRecordByIndex (sd, handle, index, record4, NULL, NULL, NULL); + CHECK_RESULT(dlp_ReadRecordByIndex); + if (memcmp(record1, record4->data, sizeof(record1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Record by index mismatch\n")); + goto error; + } + result = dlp_ReadNextModifiedRec (sd, handle, record4, NULL, NULL, NULL, NULL); + CHECK_RESULT(dlp_ReadNextModifiedRec); + if (memcmp(record2, record4->data, sizeof(record2) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Next modified record mismatch\n")); + goto error; + } + + /* Reset because of the above next modified record call */ + result = dlp_ResetDBIndex (sd, handle); + CHECK_RESULT(dlp_ResetDBIndex) + + /* This is a DLP 1.1 call, but pilot-link has a 1.0 implementation */ + result = dlp_ReadNextRecInCategory (sd, handle, 3, record4, NULL, NULL, NULL); + CHECK_RESULT(dlp_ReadNextRecInCategory) + if (memcmp(record3, record4->data, sizeof(record3) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextRecInCategory mismatch\n")); + goto error; + } + + /* Reset because of the above next record in category call */ + result = dlp_ResetDBIndex (sd, handle); + CHECK_RESULT(dlp_ResetDBIndex) + + /* This is a DLP 1.1 call, but pilot-link has a 1.0 implementation */ + result = dlp_ReadNextModifiedRecInCategory (sd, handle, 2, record4, NULL, NULL, NULL); + CHECK_RESULT(dlp_ReadNextModifiedRecInCategory) + if (memcmp(record2, record4->data, sizeof(record2) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextModifiedRecInCategory mismatch\n")); + goto error; + } + + /* Reset because of the above next modified record in category call */ + result = dlp_ResetDBIndex (sd, handle); + CHECK_RESULT(dlp_ResetDBIndex) + + /* Move a category and try to read the record back in */ + result = dlp_MoveCategory (sd, handle, 1, 4); + CHECK_RESULT(dlp_MoveCategory) + result = dlp_ReadNextRecInCategory (sd, handle, 4, record4, NULL, NULL, NULL); + CHECK_RESULT(dlp_ReadNextRecInCategory) + if (memcmp(record1, record4->data, sizeof(record1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextRecInCategory mismatch\n")); + goto error; + } + + /* Delete records in various ways */ + result = dlp_DeleteRecord (sd, handle, 0, rid1); + CHECK_RESULT(dlp_DeleteRecord <Single>); + result = dlp_ReadRecordById (sd, handle, rid1, record4, NULL, NULL, NULL); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted record could still be read\n")); + goto error; + } + result = dlp_DeleteCategory (sd, handle, 3); + CHECK_RESULT(dlp_DeleteCategory); + result = dlp_ReadRecordById (sd, handle, rid3, record4, NULL, NULL, NULL); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted category could still be read\n")); + goto error; + } + result = dlp_DeleteRecord (sd, handle, 1, 0); + CHECK_RESULT(dlp_DeleteRecord <All>); + result = dlp_ReadRecordById (sd, handle, rid2, record4, NULL, NULL, NULL); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted all record could still be read\n")); + goto error; + } + + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + result = dlp_DeleteDB (sd, 0, "TestRecord"); + CHECK_RESULT(dlp_DeleteDB); + + /********************************************************************* + * + * Test: Resource + * + * Direct Testing Functions: + * dlp_WriteResource + * dlp_ReadResourceByType + * dlp_ReadResourceByIndex + * dlp_DeleteResource + * + * Indirect Testing Functions: + * dlp_CreateDB + * dlp_CloseDB + * dlp_DeleteDB + * + *********************************************************************/ + memset (ires1, '\0', sizeof (ires1)); + memset (dres1, '\0', sizeof (dres1)); + ires1[3] = 'T'; + dres1[4] = 'T'; + + result = dlp_CreateDB (sd, CREATOR, DATA, 0, dlpDBFlagResource, 1, "TestResource", &handle); + CHECK_RESULT(dlp_CreateDB); + + /* Write out some resources */ + result = dlp_WriteResource (sd, handle, INFO, 1, ires1, sizeof(ires1)); + CHECK_RESULT(dlp_WriteResource); + result = dlp_WriteResource (sd, handle, DATA, 0, dres1, sizeof(dres1)); + CHECK_RESULT(dlp_WriteResource); + + /* Read in the resources by various methods */ + result = dlp_ReadResourceByType (sd, handle, INFO, 1, ires2, &index); + CHECK_RESULT(dlp_ReadResourceByType) + if (memcmp(ires1, ires2->data, sizeof(ires1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by type mismatch\n")); + goto error; + } + result = dlp_ReadResourceByIndex (sd, handle, index, ires2, &type, &id_); + CHECK_RESULT(dlp_ReadResourceByIndex) + if (memcmp(ires1, ires2->data, sizeof(ires1) != 0)) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index mismatch\n")); + goto error; + } + if (type != INFO) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index return type mismatch\n")); + goto error; + } + if (id_ != 1) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index return id mismatch\n")); + goto error; + } + + /* Delete resources by the various methods */ + result = dlp_DeleteResource (sd, handle, 0, INFO, 1); + CHECK_RESULT(dlp_DeleteResource <Single>) + result = dlp_ReadResourceByType (sd, handle, INFO, 1, ires2, &index); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted resource could still be read\n")); + goto error; + } + result = dlp_DeleteResource (sd, handle, 1, INFO, 1); + CHECK_RESULT(dlp_DeleteResource <All>) + result = dlp_ReadResourceByType (sd, handle, DATA, 0, dres2, &index); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted all resource could still be read\n")); + goto error; + } + + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB) + result = dlp_DeleteDB (sd, 0, "TestResource"); + CHECK_RESULT(dlp_DeleteDB) + + /********************************************************************* + * + * Test: Database Cleanup + * + * Direct Testing Functions: + * dlp_CleanUpDatabase + * dlp_ResetSyncFlags + * + * Indirect Testing Functions: + * dlp_CreateDB + * dlp_WriteRecord + * dlp_CloseDB + * dlp_DeleteDB + * + *********************************************************************/ + result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle); + CHECK_RESULT(dlp_CreateDB); + + /* Create dummy records */ + result = dlp_WriteRecord (sd, handle, dlpRecAttrDeleted, 0, 0, record1, sizeof(record1), &rid1); + CHECK_RESULT(dlp_WriteRecord); + result = dlp_WriteRecord (sd, handle, dlpRecAttrDirty, 0, 0, record2, sizeof(record2), &rid2); + CHECK_RESULT(dlp_WriteRecord); + + /* Call the test functions */ + result = dlp_CleanUpDatabase (sd, handle); + CHECK_RESULT(dlp_CleanUpDatabase); + result = dlp_ResetSyncFlags (sd, handle); + CHECK_RESULT(dlp_ResetSyncFlags); + + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + + /* Confirm the test functions worked */ + result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "TestRecord", &handle); + CHECK_RESULT(dlp_OpenDB); + + result = dlp_ReadRecordById (sd, handle, rid1, record4, NULL, NULL, NULL); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Cleaned up record could still be read\n")); + goto error; + } + result = dlp_ReadNextModifiedRec (sd, handle, record4, NULL, NULL, NULL, NULL); + if (result >= 0) { + LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Modified recorded could still be read\n")); + goto error; + } + + result = dlp_CloseDB (sd, handle); + CHECK_RESULT(dlp_CloseDB); + result = dlp_DeleteDB (sd, 0, "TestRecord"); + CHECK_RESULT(dlp_DeleteDB); + + /********************************************************************* + * + * Test: Sync Log + * + * Direct Testing Functions: + * dlp_AddSyncLogEntry + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_AddSyncLogEntry (sd, "dlp-test added sync log entry"); + CHECK_RESULT(dlp_AddSyncLogEntry); + + /********************************************************************* + * + * Test: End Sync + * + * Direct Testing Functions: + * dlp_EndOfSync + * + * Indirect Testing Functions: + * None + * + *********************************************************************/ + result = dlp_EndOfSync (sd, dlpEndCodeNormal); + CHECK_RESULT(dlp_EndOfSync); + + t1 = time (NULL); + LOG((PI_DBG_USER, PI_DBG_LVL_INFO, "DLPTEST Ending at %s", ctime (&t1))); + + error: + pi_close (sd); + pi_buffer_free (record4); + pi_buffer_free (ires2); + pi_buffer_free (dres2); + pi_buffer_free(appblock); + return 0; +} + |