liberregxml/tst/main.c File Reference

test liberregxml the functions of getting the functions of setting the functions of importing and exporting the functions of rwlocking the functions of validation the functions of minset the functions of the time consumption

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "erregapi.h"
#include "erregbasis.h"
#include "erregnwprofiles.h"
#include "erreglog.h"

Go to the source code of this file.

Functions

static void getAllSettings (void)

static gboolean setAllSettings (void)

static void testPCProfiles (void)

static void testNetworkProfiles (void)

static gboolean exportConfig (void)

static gboolean importConfig (void)

static void testValidation (void)

static void testMinSet (void)

static void testTimeConsumption (void)

int main ()

Detailed Description

test liberregxml the functions of getting the functions of setting the functions of importing and exporting the functions of rwlocking the functions of validation the functions of minset the functions of the time consumption

Definition in file main.c.

Function Documentation

static gboolean exportConfig ( void ) [static]

Definition at line 732 of file main.c.

00733 {
00734     return FALSE;
00735 
00736     gboolean bRet;
00737     
00738     bRet = erRegWriteLock();
00739     if (FALSE == bRet)
00740     {
00741         return FALSE;
00742     }
00743 
00744     // NOT TESTED: bRet = erRegExportConfig();
00745    
00746     erRegUnlock();
00747 
00748     return bRet;
00749 }

Here is the call graph for this function:

static void getAllSettings ( void ) [static]

test extension name list.

Definition at line 104 of file main.c.

00105 {
00106 
00107     gboolean bRet;
00108     regLoad_t ret;
00109 
00110     // locking read lock
00111     bRet = erRegReadLock();
00112     if (FALSE == bRet)
00113     {
00114         ERREG_ERRORPRINTF("error");
00115         return;
00116     }
00117 
00118     // loading registry
00119     ret = erRegLoad(regBasis_t);
00120 /* 
00121  *  for getting, even thougth loading registry fails, 
00122  *  we still can get the settings
00123     if (loadError_t == ret)
00124     {
00125         ERREG_ERRORPRINTF("error");
00126         erRegUnlock();
00127         return;
00128     }
00129 */
00130     regVersion_t *theVersion = erRegGetVersion();
00131     erRegFreeVersion(theVersion);
00132     theVersion = NULL;
00133 
00134     regUserProfile_t *theUserProfile = erRegGetUserProfile();
00135     erRegFreeUserProfile(theUserProfile);
00136     theUserProfile = NULL;
00137 
00138     regUserSetting_t *theUserSetting = erRegGetUserSetting();
00139     erRegFreeUserSetting(theUserSetting);
00140     theUserSetting = NULL;
00141 
00142     regPCConfig_t *thePCConfig = NULL;
00143     regPCProfile_t **thePCs = NULL;
00144     erRegGetPCProfiles(&thePCConfig, &thePCs);
00145     erRegFreePCProfiles(thePCConfig, thePCs);
00146     thePCConfig = NULL;
00147     thePCs = NULL;
00148         
00149     regAutoConnect_t *theAutoConnect = erRegGetAutoConnect();
00150     erRegFreeAutoConnect(theAutoConnect);
00151     theAutoConnect = NULL;
00152 
00153     regContentCategory_t *theContentCategory = erRegGetContentCategory(BOOKS_CATEGORY);
00154     erRegFreeContentCategory(theContentCategory);
00155     theContentCategory = NULL;
00156 
00157     theContentCategory = erRegGetContentCategory(NEWSPAPERS_CATEGORY);
00158     erRegFreeContentCategory(theContentCategory);
00159     theContentCategory = NULL;
00160 
00161     theContentCategory = erRegGetContentCategory(NOTES_CATEGORY);
00162     erRegFreeContentCategory(theContentCategory);
00163     theContentCategory = NULL;
00164 
00165     theContentCategory = erRegGetContentCategory(DOCUMENTS_CATEGORY);
00166     erRegFreeContentCategory(theContentCategory);
00167     theContentCategory = NULL;
00168 
00169     theContentCategory = erRegGetContentCategory(MAIN_CATEGORY);
00170     erRegFreeContentCategory(theContentCategory);
00171     theContentCategory = NULL;
00172 
00173     theContentCategory = erRegGetContentCategory(SD_CATEGORY);
00174     erRegFreeContentCategory(theContentCategory);
00175     theContentCategory = NULL;
00176 
00177     theContentCategory = erRegGetContentCategory(USB_CATEGORY);
00178     erRegFreeContentCategory(theContentCategory);
00179     theContentCategory = NULL;
00180 
00181     theContentCategory = erRegGetContentCategory(MODE_CATEGORY);
00182     erRegFreeContentCategory(theContentCategory);
00183     theContentCategory = NULL;
00184 
00185     theContentCategory = erRegGetContentCategory(DOWNLOAD_HISTORY);
00186     erRegFreeContentCategory(theContentCategory);
00187     theContentCategory = NULL;
00188 
00189     theContentCategory = erRegGetContentCategory(SEARCH_RESULT);
00190     erRegFreeContentCategory(theContentCategory);
00191     theContentCategory = NULL;
00192 
00193     theContentCategory = erRegGetContentCategory(RECENTDOCUMENTS);
00194     erRegFreeContentCategory(theContentCategory);
00195     theContentCategory = NULL;
00196 
00197     regLastRead_t *theLastRead = erRegGetLastRead(BOOKS_CATEGORY);
00198     erRegFreeLastRead(theLastRead);
00199     theLastRead = NULL;
00200 
00201     theLastRead = erRegGetLastRead(NEWSPAPERS_CATEGORY);
00202     erRegFreeLastRead(theLastRead);
00203     theLastRead = NULL;
00204 
00205     theLastRead = erRegGetLastRead(DOCUMENTS_CATEGORY);
00206     erRegFreeLastRead(theLastRead);
00207     theLastRead = NULL;
00208 
00209     theLastRead = erRegGetLastRead(NOTES_CATEGORY);
00210     erRegFreeLastRead(theLastRead);
00211     theLastRead = NULL;
00212 
00213     regUserAppList_t *theUserAppList = NULL;
00214     regUserApp_t *theUserApp = NULL;
00215     int i;
00216     theUserAppList = erRegGetUserAppList();
00217     if (theUserAppList)
00218     {
00219         for (i = 0; i < theUserAppList->uaIDArraySize; i++)
00220         {
00221             theUserApp = erRegGetUserApp(theUserAppList->uaIDArray[i]);
00222             erRegFreeUserApp(theUserApp);
00223         theUserApp = NULL;
00224         }
00225     }
00226     erRegFreeUserAppList(theUserAppList);
00227     theUserAppList = NULL;
00228     
00229     
00231     {
00232         static const char * extTable [] = 
00233         {
00234             "pdf",
00235             "eba",
00236             "xeb",
00237             "xhtml",
00238             "html",
00239             "txt",
00240             "jpg",
00241             "jpeg",                                                                                                                                    
00242             "png",            
00243             "bmp",                                                            
00244             0,
00245         };
00246         static const int extTableSize = sizeof(extTable)/sizeof(extTable[0]);
00247         int index = 0;
00248         for(; index < extTableSize; ++index)
00249         {             
00250             regExtInfoList_t *theExtInfoList = erRegGetExtInfoList((char *)extTable[index]);
00251             erRegFreeExtInfoList(theExtInfoList);
00252             theExtInfoList = NULL;
00253         }
00254     }
00255 
00256     regStartUp_t *theStartUp = erRegGetStartUp();
00257     erRegFreeStartUp(theStartUp);
00258     theStartUp = NULL;
00259 
00260     // unloading registry
00261     erRegUnload(regBasis_t);
00262     
00263     // test on nwprofiles registry
00264     ret = erRegLoad(regNWProfiles_t);
00265     
00266     regNetworkConfig_t *theNetworkConfig = NULL;
00267     regNetworkProfile_t **theNetworks = NULL;
00268     erRegGetNetworkProfiles(&theNetworkConfig, &theNetworks);
00269     erRegFreeNetworkProfiles(theNetworkConfig, theNetworks);
00270     theNetworkConfig = NULL;
00271     theNetworks = NULL;
00272 
00273     regLastConnect_t *theLastConnect = erRegGetLastConnect();
00274     erRegFreeLastConnect(theLastConnect);
00275     theLastConnect = NULL;
00276 
00277     erRegGetAutoConnectWlan();
00278 
00279     erRegUnload(regNWProfiles_t);
00280     
00281     // test on toolbar registry
00282     ret = erRegLoad(regToolbar_t);
00283     if (loadOk_t == ret)
00284     {
00285         regIconSet_t *theIconSet = erRegGetIconSet();
00286         erRegFreeIconSet(theIconSet);
00287         theIconSet = NULL;
00288     }
00289     erRegUnload(regToolbar_t);
00290     
00291     // unlocking read lock
00292     erRegUnlock();
00293 }

Here is the call graph for this function:

static gboolean importConfig ( void ) [static]

Definition at line 751 of file main.c.

00752 {
00753     return FALSE;
00754 
00755     gboolean bRet;
00756 
00757     bRet = erRegWriteLock();
00758     if (FALSE == bRet)
00759     {
00760         return FALSE;
00761     }
00762 
00763     // NOT TESTED: bRet = erRegImportConfig();
00764 
00765     erRegUnlock();
00766 
00767     return bRet;
00768 }

Here is the call graph for this function:

int main ( )

Definition at line 60 of file main.c.

00061 {
00062     gboolean bRet;
00063 
00064     // initialize rwlock
00065     bRet = erRegRWLockInit();
00066     if (FALSE == bRet)
00067     {
00068         ERREG_ERRORPRINTF("error");
00069         return 0;
00070     }
00071     // get all settings
00072     getAllSettings();
00073 
00074     // set all settings
00075     bRet = setAllSettings();
00076 
00077     // test pc profiles
00078     testPCProfiles();
00079     
00080     // test network profiles
00081     testNetworkProfiles();
00082 
00083     // export device configuration
00084     exportConfig();
00085 
00086     // import device configuration
00087     importConfig();
00088 
00089     // test validation
00090     testValidation(); 
00091     
00092     // test minset
00093     testMinSet();
00094     
00095     // test time cosumption
00096     testTimeConsumption();
00097 
00098     // destroy rwlock
00099     erRegRWLockDestroy();
00100 
00101     return 0;
00102 }

Here is the call graph for this function:

static gboolean setAllSettings ( void ) [static]

Functions xxRegNewYyy() removed from library because only used in test application **

regVersion_t *theVersion = basisRegNewVersion(); regUserProfile_t *theUserProfile = basisRegNewUserProfile(); regUserSetting_t *theUserSetting = basisRegNewUserSetting();

regPCConfig_t *thePCConfig = basisRegNewPCConfig(2); regPCProfile_t *thePCProfile0 = basisRegNewPCProfile(thePCConfig->pcList[0]); regPCProfile_t *thePCProfile1 = basisRegNewPCProfile(thePCConfig->pcList[1]); g_free(thePCProfile1->username); g_free(thePCProfile1->password); thePCProfile1->username = g_strdup("yehong"); thePCProfile1->password = g_strdup("!wyh19801206");

regAutoConnect_t *theAutoConnect = basisRegNewAutoConnect();

regContentCategory_t *theContentCategory = basisRegNewContentCategory(MODE_CATEGORY);

regContentCategory_t *theBooks = basisRegNewContentCategory(BOOKS_CATEGORY); regContentCategory_t *theNewspapers = basisRegNewContentCategory(NEWSPAPERS_CATEGORY); regContentCategory_t *theNotes = basisRegNewContentCategory(NOTES_CATEGORY); regContentCategory_t *theDocuments = basisRegNewContentCategory(DOCUMENTS_CATEGORY); regContentCategory_t *theCF = basisRegNewContentCategory(CF_CATEGORY); regContentCategory_t *theMain = basisRegNewContentCategory(MAIN_CATEGORY); regContentCategory_t *theSD = basisRegNewContentCategory(SD_CATEGORY); regContentCategory_t *theUSB = basisRegNewContentCategory(USB_CATEGORY); regContentCategory_t *theDownload = basisRegNewContentCategory(DOWNLOAD_HISTORY); regContentCategory_t *theSearch = basisRegNewContentCategory(SEARCH_RESULT); regContentCategory_t *theRecent = basisRegNewContentCategory(RECENT_DOCUMENTS);

regLastRead_t *theBook = basisRegNewLastRead(BOOKS_CATEGORY); regLastRead_t *theNewspaper = basisRegNewLastRead(NEWSPAPERS_CATEGORY); regLastRead_t *theNote = basisRegNewLastRead(NOTES_CATEGORY); regLastRead_t *theDocument = basisRegNewLastRead(DOCUMENTS_CATEGORY);

theDocument->extension = g_strdup("pdf"); theDocument->documentPath = g_strdup("/mnt/free/documents/bible.pdf/bible.pdf"); theDocument->manifestPath = g_strdup("/mnt/free/documents/bible.pdf/manifest.xml"); theDocument->position = g_strdup("5");

regUserAppList_t *theUserAppList = basisRegNewUserAppList(); regUserApp_t *theUserApp0 = basisRegNewUserApp(theUserAppList->uaIDArray[0]); regUserApp_t *theUserApp1 = basisRegNewUserApp(theUserAppList->uaIDArray[1]);

regUserApp_t *theUserApp2 = g_new0(regUserApp_t, 1);; theUserApp2->szCategory = g_strdup("viewer"); theUserApp2->szArgMask = g_strdup("<MANIFEST> <FILENAME>"); theUserApp2->szExec = g_strdup("/usr/bin/browser"); theUserApp2->xResName = g_strdup("browser"); theUserApp2->ipcChannel = 1; theUserApp2->appIconPath = g_strdup("browser.png"); theUserApp2->extensionArray = g_new0(char *, 4 + 1); theUserApp2->extensionArraySize = 4; theUserApp2->extensionArray[0] = g_strdup("html"); theUserApp2->extensionArray[1] = g_strdup("htm"); theUserApp2->extensionArray[2] = g_strdup("xhtml"); theUserApp2->extensionArray[3] = g_strdup("txt"); theUserApp2->extensionArray[4] = NULL;

extensionInfos regExtInfo_t *theExtInfo1 = basisRegNewExtInfo(); regExtInfo_t *theExtInfo2 = basisRegNewExtInfo(); theExtInfo1->associateApp = g_strdup("IPDF"); theExtInfo1->extName = g_strdup("pdf"); theExtInfo1->iconLocation = g_strdup("/usr/share/contentlister/Icon_books.png");

theExtInfo2->associateApp = g_strdup("EBA"); theExtInfo2->extName = g_strdup("eba"); theExtInfo2->iconLocation = g_strdup("/usr/share/contentlister/Icon_books.png");

regStartUp_t *theStartUp = basisRegNewStartUp();

bRet = erRegSetVersion(theVersion); bRet = erRegSetUserProfile(theUserProfile); bRet = erRegSetUserSetting(theUserSetting);

bRet = erRegRemovePCConfig(); bRet = erRegSetPCConfig(thePCConfig); bRet = erRegSetPCProfile(thePCConfig->pcList[0], thePCProfile0); bRet = erRegSetPCProfile(thePCConfig->pcList[1], thePCProfile1);

bRet = erRegSetAutoConnect(theAutoConnect);

bRet = erRegSetContentCategory(MODE_CATEGORY, theContentCategory);

bRet = erRegSetContentCategory(BOOKS_CATEGORY, theBooks); bRet = erRegSetContentCategory(NEWSPAPERS_CATEGORY, theNewspapers); bRet = erRegSetContentCategory(NOTES_CATEGORY, theNotes); bRet = erRegSetContentCategory(DOCUMENTS_CATEGORY, theDocuments); bRet = erRegSetContentCategory(CF_CATEGORY, theCF); bRet = erRegSetContentCategory(MAIN_CATEGORY, theMain); bRet = erRegSetContentCategory(SD_CATEGORY, theSD); bRet = erRegSetContentCategory(USB_CATEGORY, theUSB); bRet = erRegSetContentCategory(DOWNLOAD_HISTORY, theDownload); bRet = erRegSetContentCategory(SEARCH_RESULT, theSearch); bRet = erRegSetContentCategory(RECENTDOCUMENTS, theRecent);

bRet = erRegSetLastRead(BOOKS_CATEGORY, theBook); bRet = erRegSetLastRead(NEWSPAPERS_CATEGORY, theNewspaper); bRet = erRegSetLastRead(NOTES_CATEGORY, theNote); bRet = erRegSetLastRead(DOCUMENTS_CATEGORY, theDocument);

bRet = erRegSetUserApp(theUserAppList->uaIDArray[0], theUserApp0); bRet = erRegSetUserApp(theUserAppList->uaIDArray[1], theUserApp1); bRet = erRegSetUserApp("BROWSER", theUserApp2);

bRet = erRegSetExtInfo("pdf", theExtInfo1); bRet = erRegSetExtInfo("eba", theExtInfo2);

bRet = erRegSetStartUp(theStartUp);

erRegFreeVersion(theVersion); erRegFreeUserProfile(theUserProfile); erRegFreeUserSetting(theUserSetting);

erRegFreePCConfig(thePCConfig); erRegFreePCProfile(thePCProfile0); erRegFreePCProfile(thePCProfile1);

erRegFreeAutoConnect(theAutoConnect);

erRegFreeContentCategory(theContentCategory);

erRegFreeContentCategory(theBooks); erRegFreeContentCategory(theNewspapers); erRegFreeContentCategory(theNotes); erRegFreeContentCategory(theDocuments); erRegFreeContentCategory(theCF); erRegFreeContentCategory(theMain); erRegFreeContentCategory(theSD); erRegFreeContentCategory(theUSB); erRegFreeContentCategory(theDownload); erRegFreeContentCategory(theSearch); erRegFreeContentCategory(theRecent);

erRegFreeLastRead(theBook); erRegFreeLastRead(theNewspaper); erRegFreeLastRead(theNote); erRegFreeLastRead(theDocument);

erRegFreeUserAppList(theUserAppList); erRegFreeUserApp(theUserApp0); erRegFreeUserApp(theUserApp1);

erRegFreeUserApp(theUserApp2);

erRegFreeExtInfoList(theExtInfo1); erRegFreeExtInfoList(theExtInfo2);

erRegFreeStartUp(theStartUp);

write the settings into file erRegStore();

unloading registry erRegUnload(regBasis_t);

test on nwprofiles registry ret = erRegLoad(regNWProfiles_t); if (loadOk_t == ret) { regNetworkConfig_t *theNetworkConfig = nwRegNewNetworkConfig(4); regNetworkProfile_t *theNetworkProfile0 = nwRegNewNetworkProfile(theNetworkConfig->networkList[0], wired_t); regNetworkProfile_t *theNetworkProfile1 = nwRegNewNetworkProfile(theNetworkConfig->networkList[1], wireless_t); regNetworkProfile_t *theNetworkProfile2 = nwRegNewNetworkProfile(theNetworkConfig->networkList[2], wireless_t); regNetworkProfile_t *theNetworkProfile3 = nwRegNewNetworkProfile(theNetworkConfig->networkList[3], wired_t); regLastConnect_t* theLastConnect = g_new0(regLastConnect_t, 1); theLastConnect->profileConnectedIDS = 1; theLastConnect->profileConnectedPC = 4; theLastConnect->manualConnectType = ids_t;

if (theNetworkProfile2->addressMode == dhcp_t) { theNetworkProfile2->addressMode = static_t; theNetworkProfile2->ipSettings = g_new0(regIpSetting_t, 1); theNetworkProfile2->ipSettings->address = g_strdup("192.176.1.118"); theNetworkProfile2->ipSettings->netmask = g_strdup("255.255.255.0"); theNetworkProfile2->ipSettings->dns = g_strdup("202.114.1.45"); theNetworkProfile2->ipSettings->gateway = g_strdup("192.176.1.1"); } if (theNetworkProfile2->proxy == FALSE) { theNetworkProfile2->proxy = TRUE; theNetworkProfile2->proxySettings = g_new0(regProxySetting_t, 1); theNetworkProfile2->proxySettings->address = g_strdup("isaserver.irexnet.com"); theNetworkProfile2->proxySettings->port = g_strdup("80"); }

theNetworkProfile3->connection = dialup_t; theNetworkProfile3->dialupSettings = g_new0(regDialupSetting_t, 1); theNetworkProfile3->dialupSettings->phone = g_strdup("12345678"); theNetworkProfile3->dialupSettings->user = g_strdup("CDMA"); theNetworkProfile3->dialupSettings->password = g_strdup("sldlala");

bRet = erRegRemoveNetworkConfig(); bRet = erRegSetNetworkConfig(theNetworkConfig); bRet = erRegSetNetworkProfile(theNetworkConfig->networkList[0], theNetworkProfile0); bRet = erRegSetNetworkProfile(theNetworkConfig->networkList[1], theNetworkProfile1); bRet = erRegSetNetworkProfile(theNetworkConfig->networkList[2], theNetworkProfile2); bRet = erRegSetNetworkProfile(theNetworkConfig->networkList[3], theNetworkProfile3);

bRet = erRegSetLastConnect(theLastConnect); bRet = erRegSetAutoConnectWlan(FALSE);

erRegFreeNetworkConfig(theNetworkConfig); erRegFreeNetworkProfile(theNetworkProfile0); erRegFreeNetworkProfile(theNetworkProfile1); erRegFreeNetworkProfile(theNetworkProfile2); erRegFreeNetworkProfile(theNetworkProfile3);

erRegFreeLastConnect(theLastConnect);

erRegStore(); erRegUnload(regNWProfiles_t); }

unlocking write lock erRegUnlock();

return TRUE;

Functions xxRegNewYyy() removed from library because only used in test application

Definition at line 295 of file main.c.

00296 {
00297     return FALSE;
00298 
00299     regLoad_t ret;
00300     gboolean bRet;
00301    
00302     // locking write lock
00303     bRet = erRegWriteLock();
00304     if (FALSE == bRet)
00305     {
00306         ERREG_ERRORPRINTF("error");
00307         return FALSE;
00308     }
00309     
00310     // loading registry
00311     ret = erRegLoad(regBasis_t);
00312     if (loadError_t == ret)
00313     {
00314         ERREG_ERRORPRINTF("error");
00315         erRegUnlock();
00316         return FALSE;
00317     }
00318 
00545 }

Here is the call graph for this function:

static void testMinSet ( void ) [static]

Functions xxRecoverFromMinSet() have been removed **

basisRegRecoverFromMinSet(); nwRegRecoverFromMinSet(); erRegUnlock(); return;

Functions xxRecoverFromMinSet() have been removed

Functions xxRegNewYyy() removed from library because only used in test application **

regVersion_t *theVersion = basisRegNewVersion(); regUserProfile_t *theUserProfile = basisRegNewUserProfile(); regUserSetting_t *theUserSetting = basisRegNewUserSetting();

regPCConfig_t *thePCConfig = NULL; regPCProfile_t **thePCs = NULL; basisRegNewPCProfiles(&thePCConfig, &thePCs);

regNetworkConfig_t *theNetworkConfig = NULL; regNetworkProfile_t **theNetworks = NULL; nwRegNewNetworkProfiles(&theNetworkConfig, &theNetworks);

regAutoConnect_t *theAutoConnect = basisRegNewAutoConnect();

regContentCategory_t *theContentCategory = basisRegNewContentCategory(MODE_CATEGORY);

regLastRead_t *theLastRead = basisRegNewLastRead(BOOKS_CATEGORY);

regUserAppList_t *theUserAppList = basisRegNewUserAppList(); regUserApp_t *theUserApp0 = basisRegNewUserApp(theUserAppList->uaIDArray[0]); regUserApp_t *theUserApp1 = basisRegNewUserApp(theUserAppList->uaIDArray[1]);

regStartUp_t *theStartUp = basisRegNewStartUp();

erRegFreeVersion(theVersion); theVersion = NULL;

erRegFreeUserProfile(theUserProfile); theUserProfile = NULL;

erRegFreeUserSetting(theUserSetting); theUserSetting = NULL;

erRegFreePCProfiles(thePCConfig, thePCs); thePCConfig = NULL; thePCs = NULL;

erRegFreeNetworkProfiles(theNetworkConfig, theNetworks); theNetworkConfig = NULL; theNetworks = NULL;

erRegFreeAutoConnect(theAutoConnect); theAutoConnect = NULL;

erRegFreeContentCategory(theContentCategory); theContentCategory = NULL;

erRegFreeLastRead(theLastRead); theLastRead = NULL;

erRegFreeUserAppList(theUserAppList); erRegFreeUserApp(theUserApp0); erRegFreeUserApp(theUserApp1); theUserAppList = NULL; theUserApp0 = NULL; theUserApp1 = NULL;

erRegFreeStartUp(theStartUp); theStartUp = NULL;

Functions xxRegNewYyy() removed from library because only used in test application

Definition at line 813 of file main.c.

00814 {
00815     return;
00816     gboolean bRet;
00817     
00818     bRet = erRegWriteLock();
00819     if (FALSE == bRet)
00820     {
00821         return;
00822     }
00823 
00896 }

Here is the call graph for this function:

static void testNetworkProfiles ( void ) [static]

Definition at line 643 of file main.c.

00644 {
00645     return;
00646 
00647     regNetworkConfig_t *pNetworkConfig = NULL;
00648     regNetworkProfile_t **pNetworks = NULL;
00649 
00650     gboolean bRet;
00651     regLoad_t ret;
00652 
00653     // locking write lock
00654     bRet = erRegWriteLock();
00655     if (FALSE == bRet)
00656     {
00657         ERREG_ERRORPRINTF("error");
00658         return;
00659     }
00660 
00661     // loading registry
00662     ret = erRegLoad(regNWProfiles_t);
00663     if (loadError_t == ret)
00664     {
00665         ERREG_ERRORPRINTF("error");
00666         erRegUnlock();
00667         return;
00668     }
00669 
00670     // get all of current network profiles 
00671     erRegGetNetworkProfiles(&pNetworkConfig, &pNetworks);
00672     if (pNetworkConfig && pNetworks)
00673     {
00674         int index;
00675         regNetworkProfile_t *theNetworkProfile = NULL;
00676 
00677         /* testing add functions */
00678 
00679         //  duplicate one network profile
00680         theNetworkProfile = erRegDupNetworkProfile(pNetworks[0]);
00681         // change something in the new network profile
00682         if (theNetworkProfile->name)
00683         {
00684             g_free(theNetworkProfile->name);
00685             theNetworkProfile->name = g_strdup("Network Environment At Home");
00686         }
00687 
00688         // add one more profile into the profile list 
00689         erRegAddNetworkProfileToList(&pNetworkConfig, &pNetworks, theNetworkProfile);
00690 
00691         /* testing delete functions */
00692 
00693         // delete one in the profile list
00694         erRegDeleteNetworkProfileFromList(&pNetworkConfig, &pNetworks, 
00695                 pNetworkConfig->networkList[(pNetworkConfig->size) / 2]);
00696 
00697         /* modify one profile in the profile list and set it as default */
00698         index = erRegGetNetworkProfileFromList(pNetworkConfig,
00699                                 pNetworkConfig->networkList[(pNetworkConfig->size) / 2]);
00700         theNetworkProfile = pNetworks[index];
00701         if (theNetworkProfile->name)
00702         {
00703             g_free(theNetworkProfile->name);
00704             theNetworkProfile->name = g_strdup("Network Environment At Office");
00705         }
00706 
00707         // set it as default
00708         erRegSetNetworkProfileDefault(&pNetworkConfig, &pNetworks, 
00709                     pNetworkConfig->networkList[(pNetworkConfig->size) / 2]);
00710 //        erRegSetNetworkProfileDefault(&pNetworkConfig, &pNetworks, 
00711 //                    pNetworkConfig->networkList[pNetworkConfig->size-1]);
00712 
00713 
00714         // save the changes into xml tree 
00715         const regNetworkProfile_t **p = (const regNetworkProfile_t **)pNetworks;  // const_cast
00716         erRegSetNetworkProfiles(pNetworkConfig, p);
00717 
00718         // free the memory
00719         erRegFreeNetworkProfiles(pNetworkConfig, pNetworks);
00720     }
00721     
00722     // write the settings into file
00723     erRegStore();
00724 
00725     // unloading registry
00726     erRegUnload(regNWProfiles_t);
00727 
00728     // unlocking write lock
00729     erRegUnlock();
00730 }

Here is the call graph for this function:

static void testPCProfiles ( void ) [static]

Definition at line 551 of file main.c.

00552 {
00553     return;
00554 
00555     regPCConfig_t *pPCConfig = NULL;
00556     regPCProfile_t **pPCs = NULL;
00557 
00558     gboolean bRet;
00559     regLoad_t ret;
00560 
00561     // locking write lock
00562     bRet = erRegWriteLock();
00563     if (FALSE == bRet)
00564     {
00565         ERREG_ERRORPRINTF("error");
00566         return;
00567     }
00568 
00569     // loading registry
00570     ret = erRegLoad(regBasis_t);
00571     if (loadError_t == ret)
00572     {
00573         ERREG_ERRORPRINTF("error");
00574         erRegUnlock();
00575         return;
00576     }
00577 
00578     // get all of current pc profiles 
00579     erRegGetPCProfiles(&pPCConfig, &pPCs);
00580     if (pPCConfig && pPCs)
00581     {
00582         int index;
00583         regPCProfile_t *thePCProfile = NULL;
00584 
00585         /* testing add functions */
00586 
00587         //  duplicate one pc profile
00588         thePCProfile = erRegDupPCProfile(pPCs[0]);
00589         // change something in the new pc profile
00590         if (thePCProfile->username)
00591         {
00592             g_free(thePCProfile->username);
00593             thePCProfile->username = g_strdup("alice123");
00594         }
00595         // add one more profile into the profile list 
00596         erRegAddPCProfileToList(&pPCConfig, &pPCs, thePCProfile);
00597 
00598         /* testing delete functions */
00599 
00600         // delete one in the profile list
00601         erRegDeletePCProfileFromList(&pPCConfig, &pPCs, pPCConfig->pcList[(pPCConfig->size) / 2]);
00602 
00603         /* modify one profile in the profile list and set it as default */
00604         thePCProfile = erRegGetPCProfileFromList(pPCConfig, pPCs, pPCConfig->pcList[(pPCConfig->size) / 2], &index);
00605         
00606         // modify something
00607         if (thePCProfile->username)
00608         {
00609             g_free(thePCProfile->username);
00610             thePCProfile->username = g_strdup("tom");
00611         }
00612         if (thePCProfile->password)
00613         {
00614             g_free(thePCProfile->password);
00615             thePCProfile->password = g_strdup("qwerty");
00616         }
00617         // set it as default
00618         erRegSetPCProfileDefault(&pPCConfig, &pPCs, pPCConfig->pcList[(pPCConfig->size) / 2]);
00619 //         erRegSetPCProfileDefault(&pPCConfig, &pPCs, pPCConfig->pcList[pPCConfig->size-1]);
00620 
00621         // save the changes into xml tree 
00622         const regPCProfile_t **p = (const regPCProfile_t **)pPCs;  // const_cast
00623         erRegSetPCProfiles(pPCConfig, p);
00624 
00625         // free the memory
00626         erRegFreePCProfiles(pPCConfig, pPCs);
00627     }
00628 
00629     // write the settings into file
00630     erRegStore();
00631 
00632     // unloading registry
00633     erRegUnload(regBasis_t);
00634 
00635     // unlocking write lock
00636     erRegUnlock();
00637 }

Here is the call graph for this function:

static void testTimeConsumption ( void ) [static]

Definition at line 898 of file main.c.

00899 {
00900     return;
00901 
00902     // locking read lock
00903     gboolean bRet = erRegReadLock();
00904     if (FALSE == bRet)
00905     {
00906         ERREG_ERRORPRINTF("error");
00907         return;
00908     }
00909     
00910     ERREG_TIMEDISPLAY("Begin loading registry");
00911 
00912     // loading registry
00913     regLoad_t ret = erRegLoad(regBasis_t);
00914     if (loadError_t == ret)
00915     {
00916         ERREG_ERRORPRINTF("error");
00917         erRegUnlock();
00918         return;
00919     }
00920     // unloading registry
00921     erRegUnload(regBasis_t);
00922 
00923     ret = erRegLoad(regNWProfiles_t);
00924     regNetworkConfig_t *theNetworkConfig = NULL;
00925     regNetworkProfile_t **theNetworks = NULL;
00926     erRegGetNetworkProfiles(&theNetworkConfig, &theNetworks);
00927     erRegFreeNetworkProfiles(theNetworkConfig, theNetworks);
00928     theNetworkConfig = NULL;
00929     theNetworks = NULL;
00930     erRegUnload(regNWProfiles_t);
00931  
00932     ret = erRegLoad(regToolbar_t);
00933     regIconSet_t *theIconSet = erRegGetIconSet();
00934     erRegFreeIconSet(theIconSet);
00935     theIconSet = NULL;
00936     erRegUnload(regToolbar_t);
00937 
00938     ERREG_TIMEDISPLAY("End loading registry");
00939 
00940     // unlocking read lock
00941     erRegUnlock();
00942 }

Here is the call graph for this function:

static void testValidation ( void ) [static]

Definition at line 770 of file main.c.

00771 {
00772     return;
00773     gboolean bRet;
00774     regLoad_t ret;
00775     
00776     bRet = erRegWriteLock();
00777     if (FALSE == bRet)
00778     {
00779         return;
00780     }
00781     
00782     ret = erRegLoad(regBasis_t);
00783     if (loadError_t == ret)
00784     {
00785         ERREG_ERRORPRINTF("error");
00786         erRegUnlock();
00787         return;
00788     }
00789 
00790     // write valid data
00791     regUserProfile_t *theUserProfile = erRegGetUserProfile();
00792     if (theUserProfile->password)
00793     {
00794         g_free(theUserProfile->password);
00795         theUserProfile->password = g_strdup("1234567890");
00796     }
00797     erRegSetUserProfile(theUserProfile);
00798     erRegFreeUserProfile(theUserProfile);
00799     
00800     erRegStore();
00801     
00802     // write invalid data
00803     regLastRead_t *theLastRead = erRegGetLastRead(BOOKS_CATEGORY);
00804     bRet = erRegSetLastRead("yehong", theLastRead);
00805     erRegFreeLastRead(theLastRead);
00806 
00807     erRegStore();
00808     
00809     erRegUnload(regBasis_t);
00810     erRegUnlock();
00811 }

Here is the call graph for this function:


Functions
static void	getAllSettings (void)
static gboolean	setAllSettings (void)
static void	testPCProfiles (void)
static void	testNetworkProfiles (void)
static gboolean	exportConfig (void)
static gboolean	importConfig (void)
static void	testValidation (void)
static void	testMinSet (void)
static void	testTimeConsumption (void)
int	main ()