/ Check-in [fa7403c7]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Improve the error message associated with SQLITE_FULL. Ticket #1353. Also remove error messages for obsolete error codes SQLITE_INTERNAL, SQLITE_NOTFOUND, and SQLITE_TOOBIG. (CVS 2580)
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: fa7403c7d9948cc4a6c6ed00a614e3d6a3682e78
User & Date: drh 2005-08-11 02:10:19
Context
2005-08-12
22:56
Optimize LIKE and GLOB operators in the WHERE clause. Code passes all regression tests but still needs additional tests. (CVS 2581) check-in: 3edbe8d6 user: drh tags: trunk
2005-08-11
02:10
Improve the error message associated with SQLITE_FULL. Ticket #1353. Also remove error messages for obsolete error codes SQLITE_INTERNAL, SQLITE_NOTFOUND, and SQLITE_TOOBIG. (CVS 2580) check-in: fa7403c7 user: drh tags: trunk
01:25
Add 2005 open source award badge and news announcement. (CVS 2579) check-in: 8e007f8c user: drh tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to src/main.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** Main file for the SQLite library.  The routines in this file
    13     13   ** implement the programmer interface to the library.  Routines in
    14     14   ** other files are for internal use by SQLite and should not be
    15     15   ** accessed by users of the library.
    16     16   **
    17         -** $Id: main.c,v 1.296 2005/07/15 13:05:21 drh Exp $
           17  +** $Id: main.c,v 1.297 2005/08/11 02:10:19 drh Exp $
    18     18   */
    19     19   #include "sqliteInt.h"
    20     20   #include "os.h"
    21     21   #include <ctype.h>
    22     22   
    23     23   /*
    24     24   ** The following constant value is used by the SQLITE_BIGENDIAN and
................................................................................
   230    230   const char *sqlite3ErrStr(int rc){
   231    231     const char *z;
   232    232     switch( rc ){
   233    233       case SQLITE_ROW:
   234    234       case SQLITE_DONE:
   235    235       case SQLITE_OK:         z = "not an error";                          break;
   236    236       case SQLITE_ERROR:      z = "SQL logic error or missing database";   break;
   237         -    case SQLITE_INTERNAL:   z = "internal SQLite implementation flaw";   break;
   238    237       case SQLITE_PERM:       z = "access permission denied";              break;
   239    238       case SQLITE_ABORT:      z = "callback requested query abort";        break;
   240    239       case SQLITE_BUSY:       z = "database is locked";                    break;
   241    240       case SQLITE_LOCKED:     z = "database table is locked";              break;
   242    241       case SQLITE_NOMEM:      z = "out of memory";                         break;
   243    242       case SQLITE_READONLY:   z = "attempt to write a readonly database";  break;
   244    243       case SQLITE_INTERRUPT:  z = "interrupted";                           break;
   245    244       case SQLITE_IOERR:      z = "disk I/O error";                        break;
   246    245       case SQLITE_CORRUPT:    z = "database disk image is malformed";      break;
   247         -    case SQLITE_NOTFOUND:   z = "table or record not found";             break;
   248         -    case SQLITE_FULL:       z = "database is full";                      break;
          246  +    case SQLITE_FULL:       z = "database or disk is full";              break;
   249    247       case SQLITE_CANTOPEN:   z = "unable to open database file";          break;
   250    248       case SQLITE_PROTOCOL:   z = "database locking protocol failure";     break;
   251    249       case SQLITE_EMPTY:      z = "table contains no data";                break;
   252    250       case SQLITE_SCHEMA:     z = "database schema has changed";           break;
   253         -    case SQLITE_TOOBIG:     z = "too much data for one table row";       break;
   254    251       case SQLITE_CONSTRAINT: z = "constraint failed";                     break;
   255    252       case SQLITE_MISMATCH:   z = "datatype mismatch";                     break;
   256    253       case SQLITE_MISUSE:     z = "library routine called out of sequence";break;
   257    254       case SQLITE_NOLFS:      z = "kernel lacks large file support";       break;
   258    255       case SQLITE_AUTH:       z = "authorization denied";                  break;
   259    256       case SQLITE_FORMAT:     z = "auxiliary database format error";       break;
   260    257       case SQLITE_RANGE:      z = "bind or column index out of range";     break;

Changes to src/sqlite.h.in.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the SQLite library
    13     13   ** presents to client programs.
    14     14   **
    15         -** @(#) $Id: sqlite.h.in,v 1.138 2005/07/23 02:17:03 drh Exp $
           15  +** @(#) $Id: sqlite.h.in,v 1.139 2005/08/11 02:10:19 drh Exp $
    16     16   */
    17     17   #ifndef _SQLITE3_H_
    18     18   #define _SQLITE3_H_
    19     19   #include <stdarg.h>     /* Needed for the definition of va_list */
    20     20   
    21     21   /*
    22     22   ** Make sure we can call this stuff from C++.
................................................................................
   154    154   );
   155    155   
   156    156   /*
   157    157   ** Return values for sqlite3_exec() and sqlite3_step()
   158    158   */
   159    159   #define SQLITE_OK           0   /* Successful result */
   160    160   #define SQLITE_ERROR        1   /* SQL error or missing database */
   161         -#define SQLITE_INTERNAL     2   /* An internal logic error in SQLite */
          161  +#define SQLITE_INTERNAL     2   /* NOT USED. Internal logic error in SQLite */
   162    162   #define SQLITE_PERM         3   /* Access permission denied */
   163    163   #define SQLITE_ABORT        4   /* Callback routine requested an abort */
   164    164   #define SQLITE_BUSY         5   /* The database file is locked */
   165    165   #define SQLITE_LOCKED       6   /* A table in the database is locked */
   166    166   #define SQLITE_NOMEM        7   /* A malloc() failed */
   167    167   #define SQLITE_READONLY     8   /* Attempt to write a readonly database */
   168    168   #define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
   169    169   #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
   170    170   #define SQLITE_CORRUPT     11   /* The database disk image is malformed */
   171         -#define SQLITE_NOTFOUND    12   /* (Internal Only) Table or record not found */
          171  +#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
   172    172   #define SQLITE_FULL        13   /* Insertion failed because database is full */
   173    173   #define SQLITE_CANTOPEN    14   /* Unable to open the database file */
   174    174   #define SQLITE_PROTOCOL    15   /* Database lock protocol error */
   175    175   #define SQLITE_EMPTY       16   /* Database is empty */
   176    176   #define SQLITE_SCHEMA      17   /* The database schema changed */
   177         -#define SQLITE_TOOBIG      18   /* Too much data for one row of a table */
          177  +#define SQLITE_TOOBIG      18   /* NOT USED. Too much data for one row */
   178    178   #define SQLITE_CONSTRAINT  19   /* Abort due to contraint violation */
   179    179   #define SQLITE_MISMATCH    20   /* Data type mismatch */
   180    180   #define SQLITE_MISUSE      21   /* Library used incorrectly */
   181    181   #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
   182    182   #define SQLITE_AUTH        23   /* Authorization denied */
   183    183   #define SQLITE_FORMAT      24   /* Auxiliary database format error */
   184    184   #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */

Changes to src/test1.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Code for testing the printf() interface to SQLite.  This code
    13     13   ** is not included in the SQLite library.  It is used for automated
    14     14   ** testing of the SQLite library.
    15     15   **
    16         -** $Id: test1.c,v 1.152 2005/08/02 21:42:17 drh Exp $
           16  +** $Id: test1.c,v 1.153 2005/08/11 02:10:19 drh Exp $
    17     17   */
    18     18   #include "sqliteInt.h"
    19     19   #include "tcl.h"
    20     20   #include "os.h"
    21     21   #include <stdlib.h>
    22     22   #include <string.h>
    23     23   
    24     24   const char *sqlite3TestErrorName(int rc){
    25     25     const char *zName = 0;
    26     26     switch( rc ){
    27     27       case SQLITE_OK:         zName = "SQLITE_OK";          break;
    28     28       case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
    29         -    case SQLITE_INTERNAL:   zName = "SQLITE_INTERNAL";    break;
    30     29       case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
    31     30       case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
    32     31       case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
    33     32       case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
    34     33       case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
    35     34       case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
    36     35       case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
    37     36       case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
    38     37       case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
    39         -    case SQLITE_NOTFOUND:   zName = "SQLITE_NOTFOUND";    break;
    40     38       case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
    41     39       case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
    42     40       case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
    43     41       case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
    44     42       case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
    45         -    case SQLITE_TOOBIG:     zName = "SQLITE_TOOBIG";      break;
    46     43       case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
    47     44       case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
    48     45       case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
    49     46       case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
    50     47       case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
    51     48       case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
    52     49       case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;

Changes to src/test2.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Code for testing the pager.c module in SQLite.  This code
    13     13   ** is not included in the SQLite library.  It is used for automated
    14     14   ** testing of the SQLite library.
    15     15   **
    16         -** $Id: test2.c,v 1.30 2005/05/27 09:41:13 danielk1977 Exp $
           16  +** $Id: test2.c,v 1.31 2005/08/11 02:10:19 drh Exp $
    17     17   */
    18     18   #include "sqliteInt.h"
    19     19   #include "os.h"
    20     20   #include "pager.h"
    21     21   #include "tcl.h"
    22     22   #include <stdlib.h>
    23     23   #include <string.h>
................................................................................
    26     26   ** Interpret an SQLite error number
    27     27   */
    28     28   static char *errorName(int rc){
    29     29     char *zName;
    30     30     switch( rc ){
    31     31       case SQLITE_OK:         zName = "SQLITE_OK";          break;
    32     32       case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
    33         -    case SQLITE_INTERNAL:   zName = "SQLITE_INTERNAL";    break;
    34     33       case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
    35     34       case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
    36     35       case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
    37     36       case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
    38     37       case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
    39     38       case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
    40     39       case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
    41     40       case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
    42         -    case SQLITE_NOTFOUND:   zName = "SQLITE_NOTFOUND";    break;
    43     41       case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
    44     42       case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
    45     43       case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
    46     44       case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
    47     45       case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
    48         -    case SQLITE_TOOBIG:     zName = "SQLITE_TOOBIG";      break;
    49     46       case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
    50     47       case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
    51     48       case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
    52     49       case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
    53     50       default:                zName = "SQLITE_Unknown";     break;
    54     51     }
    55     52     return zName;

Changes to src/test3.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Code for testing the btree.c module in SQLite.  This code
    13     13   ** is not included in the SQLite library.  It is used for automated
    14     14   ** testing of the SQLite library.
    15     15   **
    16         -** $Id: test3.c,v 1.61 2005/01/21 08:13:15 danielk1977 Exp $
           16  +** $Id: test3.c,v 1.62 2005/08/11 02:10:19 drh Exp $
    17     17   */
    18     18   #include "sqliteInt.h"
    19     19   #include "pager.h"
    20     20   #include "btree.h"
    21     21   #include "tcl.h"
    22     22   #include <stdlib.h>
    23     23   #include <string.h>
................................................................................
    26     26   ** Interpret an SQLite error number
    27     27   */
    28     28   static char *errorName(int rc){
    29     29     char *zName;
    30     30     switch( rc ){
    31     31       case SQLITE_OK:         zName = "SQLITE_OK";          break;
    32     32       case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
    33         -    case SQLITE_INTERNAL:   zName = "SQLITE_INTERNAL";    break;
    34     33       case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
    35     34       case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
    36     35       case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
    37     36       case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
    38     37       case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
    39     38       case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
    40     39       case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
    41     40       case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
    42         -    case SQLITE_NOTFOUND:   zName = "SQLITE_NOTFOUND";    break;
    43     41       case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
    44     42       case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
    45     43       case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
    46     44       case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
    47     45       case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
    48     46       default:                zName = "SQLITE_Unknown";     break;
    49     47     }

Changes to src/test4.c.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Code for testing the the SQLite library in a multithreaded environment.
    13     13   **
    14         -** $Id: test4.c,v 1.12 2004/09/06 17:24:13 drh Exp $
           14  +** $Id: test4.c,v 1.13 2005/08/11 02:10:19 drh Exp $
    15     15   */
    16     16   #include "sqliteInt.h"
    17     17   #include "tcl.h"
    18     18   #include "os.h"
    19     19   #if defined(OS_UNIX) && OS_UNIX==1 && defined(THREADSAFE) && THREADSAFE==1
    20     20   #include <stdlib.h>
    21     21   #include <string.h>
................................................................................
   371    371       Tcl_AppendResult(interp, "no such thread", 0);
   372    372       return TCL_ERROR;
   373    373     }
   374    374     thread_wait(&threadset[i]);
   375    375     switch( threadset[i].rc ){
   376    376       case SQLITE_OK:         zName = "SQLITE_OK";          break;
   377    377       case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
   378         -    case SQLITE_INTERNAL:   zName = "SQLITE_INTERNAL";    break;
   379    378       case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
   380    379       case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
   381    380       case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
   382    381       case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
   383    382       case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
   384    383       case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
   385    384       case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
   386    385       case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
   387    386       case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
   388         -    case SQLITE_NOTFOUND:   zName = "SQLITE_NOTFOUND";    break;
   389    387       case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
   390    388       case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
   391    389       case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
   392    390       case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
   393    391       case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
   394         -    case SQLITE_TOOBIG:     zName = "SQLITE_TOOBIG";      break;
   395    392       case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
   396    393       case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
   397    394       case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
   398    395       case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
   399    396       case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
   400    397       case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
   401    398       case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;

Changes to test/autoinc.test.

     7      7   #    May you find forgiveness for yourself and forgive others.
     8      8   #    May you share freely, never taking more than you give.
     9      9   #
    10     10   #*************************************************************************
    11     11   # This file implements regression tests for SQLite library.  The
    12     12   # focus of this script is testing the AUTOINCREMENT features.
    13     13   #
    14         -# $Id: autoinc.test,v 1.6 2005/06/14 02:12:46 drh Exp $
           14  +# $Id: autoinc.test,v 1.7 2005/08/11 02:10:19 drh Exp $
    15     15   #
    16     16   
    17     17   set testdir [file dirname $argv0]
    18     18   source $testdir/tester.tcl
    19     19   
    20     20   # If the library is not compiled with autoincrement support then
    21     21   # skip all tests in this file.
................................................................................
   476    476       }
   477    477     } 9223372036854775807
   478    478   }
   479    479   do_test autoinc-6.2 {
   480    480     catchsql {
   481    481       INSERT INTO t6 VALUES(NULL,1);
   482    482     }
   483         -} {1 {database is full}}
          483  +} {1 {database or disk is full}}
   484    484   
   485    485   # Allow the AUTOINCREMENT keyword inside the parentheses
   486    486   # on a separate PRIMARY KEY designation.
   487    487   #
   488    488   do_test autoinc-7.1 {
   489    489     execsql {
   490    490       CREATE TABLE t7(x INTEGER, y REAL, PRIMARY KEY(x AUTOINCREMENT));

Changes to test/capi3.test.

     7      7   #    May you find forgiveness for yourself and forgive others.
     8      8   #    May you share freely, never taking more than you give.
     9      9   #
    10     10   #***********************************************************************
    11     11   # This file implements regression tests for SQLite library.  The
    12     12   # focus of this script testing the callback-free C/C++ API.
    13     13   #
    14         -# $Id: capi3.test,v 1.33 2005/06/06 17:54:56 drh Exp $
           14  +# $Id: capi3.test,v 1.34 2005/08/11 02:10:19 drh Exp $
    15     15   #
    16     16   
    17     17   set testdir [file dirname $argv0]
    18     18   source $testdir/tester.tcl
    19     19   
    20     20   # Return the UTF-16 representation of the supplied UTF-8 string $str.
    21     21   # If $nt is true, append two 0x00 bytes as a nul terminator.
................................................................................
   571    571   file delete -force test.db-journal
   572    572   
   573    573   
   574    574   # Test the english language string equivalents for sqlite error codes
   575    575   set code2english [list \
   576    576   SQLITE_OK         {not an error} \
   577    577   SQLITE_ERROR      {SQL logic error or missing database} \
   578         -SQLITE_INTERNAL   {internal SQLite implementation flaw} \
   579    578   SQLITE_PERM       {access permission denied} \
   580    579   SQLITE_ABORT      {callback requested query abort} \
   581    580   SQLITE_BUSY       {database is locked} \
   582    581   SQLITE_LOCKED     {database table is locked} \
   583    582   SQLITE_NOMEM      {out of memory} \
   584    583   SQLITE_READONLY   {attempt to write a readonly database} \
   585    584   SQLITE_INTERRUPT  {interrupted} \
   586    585   SQLITE_IOERR      {disk I/O error} \
   587    586   SQLITE_CORRUPT    {database disk image is malformed} \
   588         -SQLITE_NOTFOUND   {table or record not found} \
   589         -SQLITE_FULL       {database is full} \
          587  +SQLITE_FULL       {database or disk is full} \
   590    588   SQLITE_CANTOPEN   {unable to open database file} \
   591    589   SQLITE_PROTOCOL   {database locking protocol failure} \
   592    590   SQLITE_EMPTY      {table contains no data} \
   593    591   SQLITE_SCHEMA     {database schema has changed} \
   594         -SQLITE_TOOBIG     {too much data for one table row} \
   595    592   SQLITE_CONSTRAINT {constraint failed} \
   596    593   SQLITE_MISMATCH   {datatype mismatch} \
   597    594   SQLITE_MISUSE     {library routine called out of sequence} \
   598    595   SQLITE_NOLFS      {kernel lacks large file support} \
   599    596   SQLITE_AUTH       {authorization denied} \
   600    597   SQLITE_FORMAT     {auxiliary database format error} \
   601    598   SQLITE_RANGE      {bind or column index out of range} \

Changes to test/diskfull.test.

     8      8   #    May you share freely, never taking more than you give.
     9      9   #
    10     10   #***********************************************************************
    11     11   # This file implements regression tests for SQLite library.  The
    12     12   # focus of this file is testing for correct handling of disk full
    13     13   # errors.
    14     14   # 
    15         -# $Id: diskfull.test,v 1.1 2004/10/01 14:38:03 drh Exp $
           15  +# $Id: diskfull.test,v 1.2 2005/08/11 02:10:19 drh Exp $
    16     16   
    17     17   set testdir [file dirname $argv0]
    18     18   source $testdir/tester.tcl
    19     19   
    20     20   do_test diskfull-1.1 {
    21     21     execsql {
    22     22       CREATE TABLE t1(x);
................................................................................
    25     25     }
    26     26   } {}
    27     27   do_test diskfull-1.2 {
    28     28     set sqlite_diskfull_pending 1
    29     29     catchsql {
    30     30       INSERT INTO t1 SELECT * FROM t1;
    31     31     }
    32         -} {1 {database is full}}
           32  +} {1 {database or disk is full}}
    33     33   do_test diskfull-1.3 {
    34     34     set sqlite_diskfull_pending 1
    35     35     catchsql {
    36     36       DELETE FROM t1;
    37     37     }
    38         -} {1 {database is full}}
           38  +} {1 {database or disk is full}}
    39     39   
    40     40   finish_test