--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sqlite3api/TEST/SRC/test_devsym.c Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,357 @@
+/*
+** 2008 Jan 22
+**
+** The author disclaims copyright to this source code. In place of
+** a legal notice, here is a blessing:
+**
+** May you do good and not evil.
+** May you find forgiveness for yourself and forgive others.
+** May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains code that modified the OS layer in order to simulate
+** different device types (by overriding the return values of the
+** xDeviceCharacteristics() and xSectorSize() methods).
+**
+** $Id: test_devsym.c,v 1.8 2008/09/12 10:22:40 danielk1977 Exp $
+*/
+#if SQLITE_TEST /* This file is used for testing only */
+
+#include "sqlite3.h"
+#include "sqliteInt.h"
+
+/*
+** Maximum pathname length supported by the devsym backend.
+*/
+#define DEVSYM_MAX_PATHNAME 512
+
+/*
+** Name used to identify this VFS.
+*/
+#define DEVSYM_VFS_NAME "devsym"
+
+typedef struct devsym_file devsym_file;
+struct devsym_file {
+ sqlite3_file base;
+ sqlite3_file *pReal;
+};
+
+/*
+** Method declarations for devsym_file.
+*/
+static int devsymClose(sqlite3_file*);
+static int devsymRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+static int devsymWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
+static int devsymTruncate(sqlite3_file*, sqlite3_int64 size);
+static int devsymSync(sqlite3_file*, int flags);
+static int devsymFileSize(sqlite3_file*, sqlite3_int64 *pSize);
+static int devsymLock(sqlite3_file*, int);
+static int devsymUnlock(sqlite3_file*, int);
+static int devsymCheckReservedLock(sqlite3_file*, int *);
+static int devsymFileControl(sqlite3_file*, int op, void *pArg);
+static int devsymSectorSize(sqlite3_file*);
+static int devsymDeviceCharacteristics(sqlite3_file*);
+
+/*
+** Method declarations for devsym_vfs.
+*/
+static int devsymOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
+static int devsymDelete(sqlite3_vfs*, const char *zName, int syncDir);
+static int devsymAccess(sqlite3_vfs*, const char *zName, int flags, int *);
+static int devsymFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+static void *devsymDlOpen(sqlite3_vfs*, const char *zFilename);
+static void devsymDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
+static void *devsymDlSym(sqlite3_vfs*,void*, const char *zSymbol);
+static void devsymDlClose(sqlite3_vfs*, void*);
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut);
+static int devsymSleep(sqlite3_vfs*, int microseconds);
+static int devsymCurrentTime(sqlite3_vfs*, double*);
+
+static sqlite3_vfs devsym_vfs = {
+ 1, /* iVersion */
+ sizeof(devsym_file), /* szOsFile */
+ DEVSYM_MAX_PATHNAME, /* mxPathname */
+ 0, /* pNext */
+ DEVSYM_VFS_NAME, /* zName */
+ 0, /* pAppData */
+ devsymOpen, /* xOpen */
+ devsymDelete, /* xDelete */
+ devsymAccess, /* xAccess */
+ devsymFullPathname, /* xFullPathname */
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+ devsymDlOpen, /* xDlOpen */
+ devsymDlError, /* xDlError */
+ devsymDlSym, /* xDlSym */
+ devsymDlClose, /* xDlClose */
+#else
+ 0, /* xDlOpen */
+ 0, /* xDlError */
+ 0, /* xDlSym */
+ 0, /* xDlClose */
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+ devsymRandomness, /* xRandomness */
+ devsymSleep, /* xSleep */
+ devsymCurrentTime /* xCurrentTime */
+};
+
+static sqlite3_io_methods devsym_io_methods = {
+ 1, /* iVersion */
+ devsymClose, /* xClose */
+ devsymRead, /* xRead */
+ devsymWrite, /* xWrite */
+ devsymTruncate, /* xTruncate */
+ devsymSync, /* xSync */
+ devsymFileSize, /* xFileSize */
+ devsymLock, /* xLock */
+ devsymUnlock, /* xUnlock */
+ devsymCheckReservedLock, /* xCheckReservedLock */
+ devsymFileControl, /* xFileControl */
+ devsymSectorSize, /* xSectorSize */
+ devsymDeviceCharacteristics /* xDeviceCharacteristics */
+};
+
+struct DevsymGlobal {
+ sqlite3_vfs *pVfs;
+ int iDeviceChar;
+ int iSectorSize;
+};
+struct DevsymGlobal g = {0, 0, 512};
+
+/*
+** Close an devsym-file.
+*/
+static int devsymClose(sqlite3_file *pFile){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsClose(p->pReal);
+}
+
+/*
+** Read data from an devsym-file.
+*/
+static int devsymRead(
+ sqlite3_file *pFile,
+ void *zBuf,
+ int iAmt,
+ sqlite_int64 iOfst
+){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Write data to an devsym-file.
+*/
+static int devsymWrite(
+ sqlite3_file *pFile,
+ const void *zBuf,
+ int iAmt,
+ sqlite_int64 iOfst
+){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Truncate an devsym-file.
+*/
+static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsTruncate(p->pReal, size);
+}
+
+/*
+** Sync an devsym-file.
+*/
+static int devsymSync(sqlite3_file *pFile, int flags){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsSync(p->pReal, flags);
+}
+
+/*
+** Return the current file-size of an devsym-file.
+*/
+static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsFileSize(p->pReal, pSize);
+}
+
+/*
+** Lock an devsym-file.
+*/
+static int devsymLock(sqlite3_file *pFile, int eLock){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsLock(p->pReal, eLock);
+}
+
+/*
+** Unlock an devsym-file.
+*/
+static int devsymUnlock(sqlite3_file *pFile, int eLock){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsUnlock(p->pReal, eLock);
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on an devsym-file.
+*/
+static int devsymCheckReservedLock(sqlite3_file *pFile, int *pResOut){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsCheckReservedLock(p->pReal, pResOut);
+}
+
+/*
+** File control method. For custom operations on an devsym-file.
+*/
+static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){
+ devsym_file *p = (devsym_file *)pFile;
+ return sqlite3OsFileControl(p->pReal, op, pArg);
+}
+
+/*
+** Return the sector-size in bytes for an devsym-file.
+*/
+static int devsymSectorSize(sqlite3_file *pFile){
+ return g.iSectorSize;
+}
+
+/*
+** Return the device characteristic flags supported by an devsym-file.
+*/
+static int devsymDeviceCharacteristics(sqlite3_file *pFile){
+ return g.iDeviceChar;
+}
+
+/*
+** Open an devsym file handle.
+*/
+static int devsymOpen(
+ sqlite3_vfs *pVfs,
+ const char *zName,
+ sqlite3_file *pFile,
+ int flags,
+ int *pOutFlags
+){
+ int rc;
+ devsym_file *p = (devsym_file *)pFile;
+ p->pReal = (sqlite3_file *)&p[1];
+ rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);
+ if( p->pReal->pMethods ){
+ pFile->pMethods = &devsym_io_methods;
+ }
+ return rc;
+}
+
+/*
+** Delete the file located at zPath. If the dirSync argument is true,
+** ensure the file-system modifications are synced to disk before
+** returning.
+*/
+static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+ return sqlite3OsDelete(g.pVfs, zPath, dirSync);
+}
+
+/*
+** Test for access permissions. Return true if the requested permission
+** is available, or false otherwise.
+*/
+static int devsymAccess(
+ sqlite3_vfs *pVfs,
+ const char *zPath,
+ int flags,
+ int *pResOut
+){
+ return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut);
+}
+
+/*
+** 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);
+}
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** Open the dynamic library located at zPath and return a handle.
+*/
+static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+ return sqlite3OsDlOpen(g.pVfs, zPath);
+}
+
+/*
+** Populate the buffer zErrMsg (size nByte bytes) with a human readable
+** utf-8 string describing the most recent error encountered associated
+** with dynamic libraries.
+*/
+static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+ sqlite3OsDlError(g.pVfs, nByte, zErrMsg);
+}
+
+/*
+** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
+*/
+static void *devsymDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+ return sqlite3OsDlSym(g.pVfs, pHandle, zSymbol);
+}
+
+/*
+** Close the dynamic library handle pHandle.
+*/
+static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){
+ sqlite3OsDlClose(g.pVfs, pHandle);
+}
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+
+/*
+** Populate the buffer pointed to by zBufOut with nByte bytes of
+** random data.
+*/
+static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+ return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);
+}
+
+/*
+** Sleep for nMicro microseconds. Return the number of microseconds
+** actually slept.
+*/
+static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){
+ return sqlite3OsSleep(g.pVfs, nMicro);
+}
+
+/*
+** Return the current time as a Julian Day number in *pTimeOut.
+*/
+static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+ return sqlite3OsCurrentTime(g.pVfs, pTimeOut);
+}
+
+/*
+** This procedure registers the devsym vfs with SQLite. If the argument is
+** true, the devsym vfs becomes the new default vfs. It is the only publicly
+** available function in this file.
+*/
+void devsym_register(int iDeviceChar, int iSectorSize){
+ if( g.pVfs==0 ){
+ g.pVfs = sqlite3_vfs_find(0);
+ devsym_vfs.szOsFile += g.pVfs->szOsFile;
+ sqlite3_vfs_register(&devsym_vfs, 0);
+ }
+ if( iDeviceChar>=0 ){
+ g.iDeviceChar = iDeviceChar;
+ }
+ if( iSectorSize>=0 ){
+ g.iSectorSize = iSectorSize;
+ }
+}
+
+#endif