//Miscellaneous tests
void Test3()
{
sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
TEST(vfs != NULL);
//Full path name - the full file name is specified
char fname[KMaxFileName];
const char* testFileName1 = "c:\\test\\abv.db";
int err = sqlite3OsFullPathname(vfs, testFileName1, KMaxFileName, fname);
TEST2(err, SQLITE_OK);
err = strncasecmp(fname, testFileName1, strlen(testFileName1));
TEST2(err, 0);
//Full path name - no drive, the full file name is not specified
const char* testFileName2 = "abv.db";
const char* expectedFileName2 = "c:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app
err = sqlite3OsFullPathname(vfs, testFileName2, KMaxFileName, fname);
TEST2(err, SQLITE_OK);
err = strncasecmp(fname, expectedFileName2, strlen(expectedFileName2));
TEST2(err, 0);
//Full path name - drive present, the full file name is not specified
const char* testFileName3 = "z:abv.db";
const char* expectedFileName3 = "z:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app
err = sqlite3OsFullPathname(vfs, testFileName3, KMaxFileName, fname);
TEST2(err, SQLITE_OK);
err = strncasecmp(fname, expectedFileName3, strlen(expectedFileName3));
TEST2(err, 0);
//Is directory writable - test 1
int res = 0;
err = sqlite3OsAccess(vfs, "c:\\test", SQLITE_ACCESS_READWRITE, &res);
TEST2(err, SQLITE_OK);
TEST2(res, 1);
//Is directory writable - test 2
err = sqlite3OsAccess(vfs, "c:\\test\\", SQLITE_ACCESS_READWRITE, &res);
TEST2(err, SQLITE_OK);
TEST2(res, 1);
//Is directory writable - test 3
//Not a valid test. It is the media that's read only, not the directory.
//err = sqlite3OsAccess(vfs, "z:\\test\\", SQLITE_ACCESS_READWRITE, &res);
//TEST2(err, SQLITE_OK);
//TEST2(res, 0);
//Random seed
const int KBufLen = 100;
char buf[KBufLen];
err = sqlite3OsRandomness(vfs, KBufLen, buf);
TEST2(err, KBufLen);
//Sleep
TUint32 start = User::FastCounter();
const TInt KSleepTime = 200000;//us
(void)sqlite3OsSleep(vfs, KSleepTime);
TUint32 end = User::FastCounter();
TInt ms = CalcMs(start, end);
TheTest.Printf(_L(" === sqlite3OsSleep() time=%d ms\r\n"), ms);
//TEST(ms >= 80 && ms <= 320);// -60%..+60%
}
/*
** Populate buffer zOut with the full canonical pathname corresponding
** to the pathname in zPath. zOut is guaranteed to point to a buffer
** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
*/
static int devsymFullPathname(
sqlite3_vfs *pVfs,
const char *zPath,
int nOut,
char *zOut
){
return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);
}
/*
** Populate buffer zOut with the full canonical pathname corresponding
** to the pathname in zPath. zOut is guaranteed to point to a buffer
** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
*/
static int tvfsFullPathname(
sqlite3_vfs *pVfs,
const char *zPath,
int nOut,
char *zOut
){
return sqlite3OsFullPathname(PARENTVFS(pVfs), zPath, nOut, zOut);
}
/*
** Attempt to open a new file for exclusive access by this process.
** The file will be opened for both reading and writing. To avoid
** a potential security problem, we do not allow the file to have
** previously existed. Nor do we allow the file to be a symbolic
** link.
**
** If delFlag is true, then make arrangements to automatically delete
** the file when it is closed.
**
** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqlite3Os2OpenExclusive( const char *zFilename, OsFile **pld, int delFlag ){
os2File f;
HFILE hf;
ULONG ulAction;
APIRET rc = NO_ERROR;
assert( *pld == 0 );
rc = DosOpen( (PSZ)zFilename, &hf, &ulAction, 0L, FILE_NORMAL,
OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_RANDOM |
OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE, (PEAOP2)NULL );
if( rc != NO_ERROR ){
return SQLITE_CANTOPEN;
}
f.h = hf;
f.locktype = NO_LOCK;
f.delOnClose = delFlag ? 1 : 0;
f.pathToDel = delFlag ? sqlite3OsFullPathname( zFilename ) : NULL;
OpenCounter( +1 );
if( delFlag ) DosForceDelete( (PSZ)sqlite3OsFullPathname( zFilename ) );
OSTRACE3( "OPEN EX %d \"%s\"\n", hf, sqlite3OsFullPathname ( zFilename ) );
return allocateOs2File( &f, pld );
}
/*
** Populate buffer zOut with the full canonical pathname corresponding
** to the pathname in zPath. zOut is guaranteed to point to a buffer
** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
*/
static int tvfsFullPathname(
sqlite3_vfs *pVfs,
const char *zPath,
int nOut,
char *zOut
){
Testvfs *p = (Testvfs *)pVfs->pAppData;
if( p->pScript && p->mask&TESTVFS_FULLPATHNAME_MASK ){
int rc;
tvfsExecTcl(p, "xFullPathname", Tcl_NewStringObj(zPath, -1), 0, 0, 0);
if( tvfsResultCode(p, &rc) ){
if( rc!=SQLITE_OK ) return rc;
}
}
return sqlite3OsFullPathname(PARENTVFS(pVfs), zPath, nOut, zOut);
}
/*
** Open a file.
*/
static int os2Open(
sqlite3_vfs *pVfs, /* Not used */
const char *zName, /* Name of the file */
sqlite3_file *id, /* Write the SQLite file handle here */
int flags, /* Open mode flags */
int *pOutFlags /* Status return flags */
){
HFILE h;
ULONG ulFileAttribute = 0;
ULONG ulOpenFlags = 0;
ULONG ulOpenMode = 0;
os2File *pFile = (os2File*)id;
APIRET rc = NO_ERROR;
ULONG ulAction;
memset(pFile, 0, sizeof(*pFile));
OSTRACE2( "OPEN want %d\n", flags );
//ulOpenMode = flags & SQLITE_OPEN_READWRITE ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY;
if( flags & SQLITE_OPEN_READWRITE ){
ulOpenMode |= OPEN_ACCESS_READWRITE;
OSTRACE1( "OPEN read/write\n" );
}else{
ulOpenMode |= OPEN_ACCESS_READONLY;
OSTRACE1( "OPEN read only\n" );
}
//ulOpenFlags = flags & SQLITE_OPEN_CREATE ? OPEN_ACTION_CREATE_IF_NEW : OPEN_ACTION_FAIL_IF_NEW;
if( flags & SQLITE_OPEN_CREATE ){
ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
OSTRACE1( "OPEN open new/create\n" );
}else{
ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
OSTRACE1( "OPEN open existing\n" );
}
//ulOpenMode |= flags & SQLITE_OPEN_MAIN_DB ? OPEN_SHARE_DENYNONE : OPEN_SHARE_DENYWRITE;
if( flags & SQLITE_OPEN_MAIN_DB ){
ulOpenMode |= OPEN_SHARE_DENYNONE;
OSTRACE1( "OPEN share read/write\n" );
}else{
ulOpenMode |= OPEN_SHARE_DENYWRITE;
OSTRACE1( "OPEN share read only\n" );
}
if( flags & (SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_TEMP_JOURNAL
| SQLITE_OPEN_SUBJOURNAL) ){
//ulFileAttribute = FILE_HIDDEN; //for debugging, we want to make sure it is deleted
ulFileAttribute = FILE_NORMAL;
pFile->delOnClose = 1;
pFile->pathToDel = (char*)malloc(sizeof(char) * pVfs->mxPathname);
sqlite3OsFullPathname(pVfs, zName, pVfs->mxPathname, pFile->pathToDel);
OSTRACE1( "OPEN hidden/delete on close file attributes\n" );
}else{
ulFileAttribute = FILE_ARCHIVED | FILE_NORMAL;
pFile->delOnClose = 0;
pFile->pathToDel = NULL;
OSTRACE1( "OPEN normal file attribute\n" );
}
//ulOpenMode |= flags & (SQLITE_OPEN_MAIN_DB | SQLITE_OPEN_TEMP_DB) ?
// OPEN_FLAGS_RANDOM : OPEN_FLAGS_SEQUENTIAL;
if( flags & (SQLITE_OPEN_MAIN_DB | SQLITE_OPEN_TEMP_DB) ){
ulOpenMode |= OPEN_FLAGS_RANDOM;
OSTRACE1( "OPEN random access\n" );
}else{
ulOpenMode |= OPEN_FLAGS_SEQUENTIAL;
OSTRACE1( "OPEN sequential access\n" );
}
ulOpenMode |= OPEN_FLAGS_FAIL_ON_ERROR;
rc = DosOpen( (PSZ)zName,
&h,
&ulAction,
0L,
ulFileAttribute,
ulOpenFlags,
ulOpenMode,
(PEAOP2)NULL );
if( rc != NO_ERROR ){
OSTRACE7( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulAttr=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
rc, zName, ulAction, ulFileAttribute, ulOpenFlags, ulOpenMode );
if( flags & SQLITE_OPEN_READWRITE ){
OSTRACE2( "OPEN %d Invalid handle\n", ((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE) );
return os2Open( 0, zName, id,
((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE),
pOutFlags );
}else{
return SQLITE_CANTOPEN;
}
}
if( pOutFlags ){
*pOutFlags = flags & SQLITE_OPEN_READWRITE ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
}
pFile->pMethod = &os2IoMethod;
pFile->h = h;
OpenCounter(+1);
OSTRACE3( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags );
return SQLITE_OK;
}
