Lines Matching defs:testcase
8441 ** The testcase() macro is used to aid in coverage testing. When
8443 ** testcase() must be evaluated both true and false in order to
8444 ** get full branch coverage. The testcase() macro is inserted
8446 ** condition/decision coverage is inadequate. For example, testcase()
8448 ** bitmask tests, testcase() can be used to make sure each bit
8450 ** where multiple cases go to the same block of code, testcase()
8456 # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
8458 # define testcase(X)
8464 ** within testcase() and assert() macros.
8540 ** to fit in 32-bits. This macro is used inside of various testcase()
15180 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
15181 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
15182 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
16261 testcase( n==sizeof(zBuf)-1 );
16262 testcase( n==sizeof(zBuf) );
16263 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
16264 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
17141 testcase( sqlite3GlobalConfig.xLog!=0 );
17154 testcase( sqlite3GlobalConfig.xLog!=0 );
17210 testcase( sqlite3GlobalConfig.xLog!=0 );
17226 testcase( sqlite3GlobalConfig.xLog!=0 );
18780 testcase( sqlite3GlobalConfig.xLog!=0 );
21615 testcase( wx>0x7fffffff );
21638 testcase( px>0x7fffffff );
21803 testcase( precision>0xfff );
22095 testcase(p->accError==STRACCUM_TOOBIG);
22096 testcase(p->accError==STRACCUM_NOMEM);
22142 testcase( p->nChar + (i64)N > 0x7fffffff );
23451 ** Routine needed to support the testcase() macro.
23520 testcase( rc );
23916 testcase( c==(-1) );
23917 testcase( c==0 );
23918 testcase( c==(+1) );
23983 testcase( i==18 );
23984 testcase( i==19 );
23985 testcase( i==20 );
24094 testcase( i==10 );
24098 testcase( v-neg==2147483647 );
24509 testcase( p[0]&0x80 );
24595 testcase( sqlite3GlobalConfig.xLog!=0 );
24609 testcase( sqlite3GlobalConfig.xLog!=0 );
24625 testcase( iA==0 ); testcase( iA==1 );
24626 testcase( iB==-1 ); testcase( iB==0 );
24628 testcase( iA>0 && LARGEST_INT64 - iA == iB );
24629 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
24632 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
24633 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
24640 testcase( iB==SMALLEST_INT64+1 );
24642 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
24672 testcase( r==(-TWOPOWER31)-1 );
24673 testcase( r==(-TWOPOWER31) );
24674 testcase( r==TWOPOWER31 );
24675 testcase( r==TWOPOWER31-1 );
43209 ** Use a testcase() macro to make sure that malloc failure within
43213 testcase( rc!=SQLITE_OK );
43361 testcase( rc==SQLITE_NOMEM );
43918 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
44178 testcase( (newSize-szPage) == currentSize );
44179 testcase( (newSize-szPage) > currentSize );
44466 testcase( rc!=SQLITE_OK );
44475 testcase( rc!=SQLITE_OK );
44482 testcase( rc!=SQLITE_OK );
44853 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
46043 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
46044 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
46045 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
46370 testcase( rc!=SQLITE_OK );
47025 testcase( rc==SQLITE_NOMEM );
47028 testcase( rc==SQLITE_NOMEM );
47380 testcase( rc==SQLITE_NOMEM );
49821 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
49822 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
49823 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
50079 testcase( szPage<=32768 );
50080 testcase( szPage>=65536 );
50611 testcase( szPage<=32768 );
50612 testcase( szPage>=65536 );
50690 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
50694 testcase( IS_BIG_INT(iOffset) );
50703 testcase( IS_BIG_INT(szDb) );
50905 testcase( pWal->szPage<=32768 );
50906 testcase( pWal->szPage>=65536 );
51238 testcase( (rc&0xff)==SQLITE_BUSY );
51239 testcase( (rc&0xff)==SQLITE_IOERR );
51240 testcase( rc==SQLITE_PROTOCOL );
51241 testcase( rc==SQLITE_OK );
51374 testcase( sz<=32768 );
51375 testcase( sz>=65536 );
51377 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
51589 testcase( (rc&0xff)==SQLITE_IOERR );
51590 testcase( rc==SQLITE_PROTOCOL );
51591 testcase( rc==SQLITE_OK );
51833 testcase( szPage<=32768 );
51834 testcase( szPage>=65536 );
51897 testcase( rc==SQLITE_BUSY );
51898 testcase( xBusy!=0 );
53739 testcase( p->iPage>0 );
54068 testcase( nPayload==pPage->maxLocal );
54069 testcase( nPayload==pPage->maxLocal+1 );
54095 testcase( surplus==maxLocal );
54096 testcase( surplus==maxLocal+1 );
54156 testcase( nSize==pPage->maxLocal );
54157 testcase( nSize==pPage->maxLocal+1 );
54164 testcase( nSize==pPage->maxLocal );
54165 testcase( nSize==pPage->maxLocal+1 );
54248 testcase( pc==iCellFirst );
54249 testcase( pc==iCellLast );
54271 testcase( cbrk+size==usableSize );
54272 testcase( pc+size==usableSize );
54332 testcase( x==4 );
54333 testcase( x==3 );
54403 testcase( gap+2==top );
54404 testcase( gap+1==top );
54405 testcase( gap==top );
54421 testcase( gap+2+nByte==top );
54652 testcase( pPage->nCell==MX_CELL(pBt) );
54676 testcase( pc==iCellFirst );
54677 testcase( pc==iCellLast );
54682 testcase( pc+sz==usableSize );
54870 testcase( pgno==0 );
56757 testcase( nPage==0 );
56759 testcase( pBt->nPage!=nPage );
57620 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
57986 testcase( pCell+nCell+1==pPage->aDataEnd );
57993 testcase( pCell+nCell+2==pPage->aDataEnd );
58139 testcase( idx>pPage->nCell );
58333 testcase( n==mxPage-1 );
58388 testcase( iTrunk==mxPage );
58456 testcase( iNewTrunk==mxPage );
58516 testcase( iPage==mxPage );
58521 testcase( iPage==mxPage );
58909 testcase( n==3 );
58910 testcase( n==4 );
58918 testcase( n==pPage->maxLocal );
58919 testcase( n==pPage->maxLocal+1 );
59064 testcase( pc==get2byte(&data[hdr+5]) );
59065 testcase( pc+sz==pPage->pBt->usableSize );
60329 testcase( rc!=SQLITE_OK );
63209 testcase( bPreserve && pMem->z==0 );
63346 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
63347 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
63451 testcase( p->flags & MEM_Dyn );
63985 testcase( nAlloc==0 );
63986 testcase( nAlloc==31 );
63987 testcase( nAlloc==32 );
64372 testcase( rc!=SQLITE_OK );
64707 testcase( iHdr==nHdr );
64708 testcase( iHdr==nHdr+1 );
64713 testcase( iField==nRec );
64714 testcase( iField==nRec+1 );
66066 testcase( p->flags & MEM_Agg );
66067 testcase( p->flags & MEM_Dyn );
66068 testcase( p->flags & MEM_Frame );
66069 testcase( p->flags & MEM_RowSet );
67478 testcase( pAux->iArg==31 );
67848 testcase( pMem->u.i<0 );
67889 testcase( pMem->u.i<0 );
67897 testcase( pMem->u.i<0 );
67905 testcase( pMem->u.i<0 );
67913 testcase( pMem->u.i<0 );
67921 testcase( pMem->u.i<0 );
68328 testcase( aKey[0]&0x80 );
68331 testcase( aKey[0]&0x80 );
68334 testcase( aKey[0]&0x80 );
68337 testcase( aKey[0]&0x80 );
68342 testcase( aKey[0]&0x80 );
68347 testcase( aKey[0]&0x80 );
68424 testcase( serial_type==12 );
68475 testcase( serial_type==12 );
68482 testcase( (d1+mem1.n)==(unsigned)nKey1 );
68483 testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
68506 testcase( serial_type==12 );
68511 testcase( (d1+nStr)==(unsigned)nKey1 );
68512 testcase( (d1+nStr+1)==(unsigned)nKey1 );
68593 testcase( lhs<0 );
68598 testcase( lhs<0 );
68603 testcase( lhs<0 );
68609 testcase( lhs<0 );
68614 testcase( lhs<0 );
68621 testcase( lhs<0 );
68753 testcase( flags & MEM_Real );
68754 testcase( flags & MEM_Null );
68755 testcase( flags & MEM_Blob );
68800 testcase( szHdr==3 );
68801 testcase( szHdr==m.n );
68809 testcase( typeRowid==1 );
68810 testcase( typeRowid==2 );
68811 testcase( typeRowid==3 );
68812 testcase( typeRowid==4 );
68813 testcase( typeRowid==5 );
68814 testcase( typeRowid==6 );
68815 testcase( typeRowid==8 );
68816 testcase( typeRowid==9 );
68821 testcase( (u32)m.n==szHdr+lenRowid );
68835 testcase( m.szMalloc!=0 );
69684 testcase( nByte<0 );
70671 testcase( zRawSql[0]==':' );
70672 testcase( zRawSql[0]=='$' );
70673 testcase( zRawSql[0]=='@' );
70674 testcase( zRawSql[0]=='#' );
71792 testcase( pOp->p5==1 );
71793 testcase( pOp->p5==2 );
71794 testcase( pOp->p5==3 );
71795 testcase( pOp->p5==4 );
72617 testcase( pOp->p2==SQLITE_AFF_TEXT );
72618 testcase( pOp->p2==SQLITE_AFF_NONE );
72619 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
72620 testcase( pOp->p2==SQLITE_AFF_INTEGER );
72621 testcase( pOp->p2==SQLITE_AFF_REAL );
72775 testcase( pIn1->flags & MEM_Int );
72776 testcase( pIn1->flags & MEM_Real );
72778 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
72782 testcase( pIn3->flags & MEM_Int );
72783 testcase( pIn3->flags & MEM_Real );
72785 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
73508 testcase( serial_type==127 );
73509 testcase( serial_type==128 );
73517 testcase( nHdr==126 );
73518 testcase( nHdr==127 );
74179 testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */
75260 testcase( n==0 );
75533 testcase( res==1 );
77123 testcase( pName->enc==SQLITE_UTF8 );
77124 testcase( pName->enc==SQLITE_UTF16BE );
77125 testcase( pName->enc==SQLITE_UTF16LE );
77364 testcase( sqlite3GlobalConfig.xLog!=0 );
77379 testcase( nVmStep>0 );
78517 testcase( rc!=SQLITE_OK );
78564 testcase( rc!=SQLITE_OK );
78596 testcase( rc!=SQLITE_OK );
78607 testcase( rc!=SQLITE_OK );
81182 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
81183 testcase( ExprHasProperty(pExpr, EP_Reduced) );
81542 testcase( pNC->ncFlags & NC_PartIdx );
81543 testcase( pNC->ncFlags & NC_IsCheck );
81667 testcase( iCol==31 );
81668 testcase( iCol==32 );
81671 testcase( iCol==31 );
81672 testcase( iCol==32 );
81787 testcase( n==BMS-1 );
81836 testcase( iCol==BMS );
81837 testcase( iCol==BMS-1 );
82066 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
82079 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
82082 testcase( pExpr->op==TK_IN );
83475 testcase( i==0 );
83476 testcase( i==1 );
83477 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
83478 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
84024 testcase( pEList && pEList->nExpr==mx );
84025 testcase( pEList && pEList->nExpr==mx+1 );
84114 testcase( pExpr->op==TK_ID );
84115 testcase( pExpr->op==TK_COLUMN );
84116 testcase( pExpr->op==TK_AGG_FUNCTION );
84117 testcase( pExpr->op==TK_AGG_COLUMN );
84138 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
84139 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
84346 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
84347 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
84712 testcase( pSelect->selFlags & SF_Distinct );
84713 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
84802 testcase( pExpr->op==TK_EXISTS );
84803 testcase( pExpr->op==TK_SELECT );
85343 ** This routine is used within assert() and testcase() macros only
85497 testcase( usedAsColumnCache(pParse, inReg, inReg) );
85512 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
85513 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
85514 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
85515 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
85516 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
85517 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
85518 testcase( regFree1==0 );
85519 testcase( regFree2==0 );
85524 testcase( op==TK_IS );
85525 testcase( op==TK_ISNOT );
85533 testcase( regFree1==0 );
85534 testcase( regFree2==0 );
85549 assert( TK_AND==OP_And ); testcase( op==TK_AND );
85550 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
85551 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
85552 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
85553 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
85554 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
85555 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
85556 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
85557 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
85558 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
85559 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
85563 testcase( regFree1==0 );
85564 testcase( regFree2==0 );
85584 testcase( regFree2==0 );
85591 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
85592 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
85594 testcase( regFree1==0 );
85602 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
85603 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
85606 testcase( regFree1==0 );
85682 testcase( i==31 );
85710 testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
85757 testcase( op==TK_EXISTS );
85758 testcase( op==TK_SELECT );
85794 testcase( regFree1==0 );
85795 testcase( regFree2==0 );
85804 testcase( regFree2==0 );
85916 testcase( pX->op==TK_COLUMN );
85918 testcase( regFree1==0 );
85937 testcase( pTest->op==TK_COLUMN );
85939 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
86474 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
86475 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
86476 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
86477 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
86478 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
86479 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
86480 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
86481 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
86512 testcase( jumpIfNull==0 );
86521 testcase( jumpIfNull==0 );
86529 testcase( jumpIfNull==0 );
86539 testcase( jumpIfNull==0 );
86544 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86545 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86546 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86547 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86548 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86549 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86550 testcase( regFree1==0 );
86551 testcase( regFree2==0 );
86556 testcase( op==TK_IS );
86557 testcase( op==TK_ISNOT );
86565 testcase( regFree1==0 );
86566 testcase( regFree2==0 );
86571 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
86572 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
86577 testcase( regFree1==0 );
86581 testcase( jumpIfNull==0 );
86604 testcase( regFree1==0 );
86605 testcase( jumpIfNull==0 );
86667 testcase( jumpIfNull==0 );
86676 testcase( jumpIfNull==0 );
86685 testcase( jumpIfNull==0 );
86695 testcase( jumpIfNull==0 );
86700 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86701 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86702 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86703 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86704 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86705 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86706 testcase( regFree1==0 );
86707 testcase( regFree2==0 );
86712 testcase( pExpr->op==TK_IS );
86713 testcase( pExpr->op==TK_ISNOT );
86721 testcase( regFree1==0 );
86722 testcase( regFree2==0 );
86729 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
86730 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
86731 testcase( regFree1==0 );
86735 testcase( jumpIfNull==0 );
86760 testcase( regFree1==0 );
86761 testcase( jumpIfNull==0 );
87006 testcase( pExpr->op==TK_AGG_COLUMN );
87007 testcase( pExpr->op==TK_COLUMN );
91461 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
92372 testcase( pCol->affinity==SQLITE_AFF_NONE );
92373 testcase( pCol->affinity==SQLITE_AFF_TEXT );
92374 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
92375 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
92376 testcase( pCol->affinity==SQLITE_AFF_REAL );
96053 testcase( IsVirtual(pTab) );
96226 testcase( mask!=0xffffffff && iCol==31 );
96227 testcase( mask!=0xffffffff && iCol==32 );
96488 testcase( mask==0 );
96825 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
96826 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
97232 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
97233 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
97556 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
97557 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
97624 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
97625 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
106172 testcase( db->flags & SQLITE_ReadUncommitted );
106185 testcase( nBytes==mxLen );
106186 testcase( nBytes==mxLen+1 );
106689 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
107012 testcase( pKI->nXField>2 );
107279 testcase( eDest==SRT_Table );
107280 testcase( eDest==SRT_EphemTab );
107359 testcase( eDest==SRT_Coroutine );
107360 testcase( eDest==SRT_Output );
107698 testcase( eDest==SRT_Table );
107699 testcase( eDest==SRT_EphemTab );
107723 testcase( eDest==SRT_Output );
107724 testcase( eDest==SRT_Coroutine );
107810 testcase( pExpr->op==TK_AGG_COLUMN );
107811 testcase( pExpr->op==TK_COLUMN );
108062 testcase( aCol==0 );
108742 testcase( rc!=SQLITE_OK );
108766 testcase( p->op==TK_EXCEPT );
108767 testcase( p->op==TK_UNION );
108815 testcase( rc!=SQLITE_OK );
108899 testcase( rc!=SQLITE_OK );
109055 testcase( pDest->eDest==SRT_Table );
109056 testcase( pDest->eDest==SRT_EphemTab );
109099 assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 );
109333 testcase( pItem->u.x.iOrderByCol > p->pEList->nExpr );
109842 testcase( pSub->selFlags & SF_Recursive );
109843 testcase( pSub->selFlags & SF_MinMaxAgg );
109900 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
109901 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
109910 testcase( pSub1->pSrc->nSrc>1 );
109929 testcase( i==SQLITE_DENY );
110826 testcase( pX->zSpan==0 );
110830 testcase( pX->zSpan==0 );
111080 testcase( nArg==0 ); /* Error condition */
111081 testcase( nArg>1 ); /* Also an error */
113877 testcase( oldmask!=0xffffffff && i==31 );
113918 testcase( i==31 );
113919 testcase( i==32 );
116382 testcase( wtFlags & TERM_VIRTUAL );
117167 testcase( db->mallocFailed );
117267 testcase( pOrTerm->wtFlags & TERM_COPIED );
117268 testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
117284 testcase( j==1 );
117340 testcase( idxNew==0 );
117463 testcase( (prereqLeft | extraRight) != prereqLeft );
117500 testcase( idxNew==0 );
117585 testcase( idxNew1==0 );
117593 testcase( idxNew2==0 );
117625 testcase( idxNew==0 );
117924 testcase( iCol==BMS );
117925 testcase( iCol==BMS-1 );
117956 testcase( pTable->nCol==BMS-1 );
117957 testcase( pTable->nCol==BMS-2 );
117977 testcase( iCol==BMS-1 );
117978 testcase( iCol==BMS );
118071 testcase( pTerm->eOperator & WO_IN );
118072 testcase( pTerm->eOperator & WO_ISNULL );
118073 testcase( pTerm->eOperator & WO_ALL );
118124 testcase( pTerm->eOperator & WO_IN );
118125 testcase( pTerm->eOperator & WO_ISNULL );
118126 testcase( pTerm->eOperator & WO_ALL );
118614 testcase( pRec->nField!=pBuilder->nRecValid );
118985 testcase( iEq==0 );
118986 testcase( bRev );
118993 testcase( bRev );
119137 /* The following testcase is true for indices with redundant columns.
119139 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
119140 testcase( pTerm->wtFlags & TERM_VIRTUAL );
119150 testcase( pTerm->eOperator & WO_ISNULL );
119151 testcase( pTerm->eOperator & WO_IN );
119543 testcase( pTerm->wtFlags & TERM_VIRTUAL );
119594 testcase( pStart->wtFlags & TERM_VIRTUAL );
119597 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
119618 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
119619 testcase( pEnd->wtFlags & TERM_VIRTUAL );
119752 testcase( bRev );
119753 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
119789 testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );
119790 testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 );
119791 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 );
119792 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 );
119821 testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
119833 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
119834 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
119835 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
119836 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
119837 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
119838 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
119861 testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
119876 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
119877 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
119878 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
119879 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
120061 testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
120240 testcase( pTerm->wtFlags & TERM_VIRTUAL );
120241 testcase( pTerm->wtFlags & TERM_CODED );
120244 testcase( pWInfo->untestedTerms==0
120285 testcase( pAlt->eOperator & WO_EQ );
120286 testcase( pAlt->eOperator & WO_IN );
120306 testcase( pTerm->wtFlags & TERM_VIRTUAL );
120307 testcase( pTerm->wtFlags & TERM_CODED );
120974 testcase( eOp & WO_GT );
120975 testcase( eOp & WO_GE );
120992 testcase( eOp & WO_LT );
120993 testcase( eOp & WO_LE );
121017 testcase( eOp & WO_IN );
121030 testcase( eOp & WO_EQ );
121031 testcase( eOp & WO_ISNULL );
121176 testcase( x==BMS-1 );
121177 testcase( x==BMS-2 );
121352 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
121547 testcase( iTerm==nConstraint-1 );
121548 testcase( j==0 );
121549 testcase( j==pWC->nTerm-1 );
121555 testcase( iTerm==15 );
121556 testcase( iTerm==16 );
121841 testcase( nOrderBy==BMS-1 );
121911 testcase( isOrderDistinct );
121948 testcase( wctrlFlags & WHERE_GROUPBY );
121949 testcase( wctrlFlags & WHERE_DISTINCTBY );
121975 testcase( distinctColumns==0 );
121982 testcase( isOrderDistinct!=0 );
121989 testcase( isOrderDistinct==0 );
122260 testcase( jj==nTo-1 );
122316 testcase( pTo->rCost==rCost );
122319 testcase( pTo->rCost==rCost+1 );
122648 testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
122661 testcase( pTabList->nSrc==BMS );
122936 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
122937 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
123254 ** Make yytestcase() the same as testcase()
123256 #define yytestcase(X) testcase(X)
127016 testcase( i==0 ); /* REINDEX */
127017 testcase( i==1 ); /* INDEXED */
127018 testcase( i==2 ); /* INDEX */
127019 testcase( i==3 ); /* DESC */
127020 testcase( i==4 ); /* ESCAPE */
127021 testcase( i==5 ); /* EACH */
127022 testcase( i==6 ); /* CHECK */
127023 testcase( i==7 ); /* KEY */
127024 testcase( i==8 ); /* BEFORE */
127025 testcase( i==9 ); /* FOREIGN */
127026 testcase( i==10 ); /* FOR */
127027 testcase( i==11 ); /* IGNORE */
127028 testcase( i==12 ); /* REGEXP */
127029 testcase( i==13 ); /* EXPLAIN */
127030 testcase( i==14 ); /* INSTEAD */
127031 testcase( i==15 ); /* ADD */
127032 testcase( i==16 ); /* DATABASE */
127033 testcase( i==17 ); /* AS */
127034 testcase( i==18 ); /* SELECT */
127035 testcase( i==19 ); /* TABLE */
127036 testcase( i==20 ); /* LEFT */
127037 testcase( i==21 ); /* THEN */
127038 testcase( i==22 ); /* END */
127039 testcase( i==23 ); /* DEFERRABLE */
127040 testcase( i==24 ); /* ELSE */
127041 testcase( i==25 ); /* EXCEPT */
127042 testcase( i==26 ); /* TRANSACTION */
127043 testcase( i==27 ); /* ACTION */
127044 testcase( i==28 ); /* ON */
127045 testcase( i==29 ); /* NATURAL */
127046 testcase( i==30 ); /* ALTER */
127047 testcase( i==31 ); /* RAISE */
127048 testcase( i==32 ); /* EXCLUSIVE */
127049 testcase( i==33 ); /* EXISTS */
127050 testcase( i==34 ); /* SAVEPOINT */
127051 testcase( i==35 ); /* INTERSECT */
127052 testcase( i==36 ); /* TRIGGER */
127053 testcase( i==37 ); /* REFERENCES */
127054 testcase( i==38 ); /* CONSTRAINT */
127055 testcase( i==39 ); /* INTO */
127056 testcase( i==40 ); /* OFFSET */
127057 testcase( i==41 ); /* OF */
127058 testcase( i==42 ); /* SET */
127059 testcase( i==43 ); /* TEMPORARY */
127060 testcase( i==44 ); /* TEMP */
127061 testcase( i==45 ); /* OR */
127062 testcase( i==46 ); /* UNIQUE */
127063 testcase( i==47 ); /* QUERY */
127064 testcase( i==48 ); /* WITHOUT */
127065 testcase( i==49 ); /* WITH */
127066 testcase( i==50 ); /* OUTER */
127067 testcase( i==51 ); /* RELEASE */
127068 testcase( i==52 ); /* ATTACH */
127069 testcase( i==53 ); /* HAVING */
127070 testcase( i==54 ); /* GROUP */
127071 testcase( i==55 ); /* UPDATE */
127072 testcase( i==56 ); /* BEGIN */
127073 testcase( i==57 ); /* INNER */
127074 testcase( i==58 ); /* RECURSIVE */
127075 testcase( i==59 ); /* BETWEEN */
127076 testcase( i==60 ); /* NOTNULL */
127077 testcase( i==61 ); /* NOT */
127078 testcase( i==62 ); /* NO */
127079 testcase( i==63 ); /* NULL */
127080 testcase( i==64 ); /* LIKE */
127081 testcase( i==65 ); /* CASCADE */
127082 testcase( i==66 ); /* ASC */
127083 testcase( i==67 ); /* DELETE */
127084 testcase( i==68 ); /* CASE */
127085 testcase( i==69 ); /* COLLATE */
127086 testcase( i==70 ); /* CREATE */
127087 testcase( i==71 ); /* CURRENT_DATE */
127088 testcase( i==72 ); /* DETACH */
127089 testcase( i==73 ); /* IMMEDIATE */
127090 testcase( i==74 ); /* JOIN */
127091 testcase( i==75 ); /* INSERT */
127092 testcase( i==76 ); /* MATCH */
127093 testcase( i==77 ); /* PLAN */
127094 testcase( i==78 ); /* ANALYZE */
127095 testcase( i==79 ); /* PRAGMA */
127096 testcase( i==80 ); /* ABORT */
127097 testcase( i==81 ); /* VALUES */
127098 testcase( i==82 ); /* VIRTUAL */
127099 testcase( i==83 ); /* LIMIT */
127100 testcase( i==84 ); /* WHEN */
127101 testcase( i==85 ); /* WHERE */
127102 testcase( i==86 ); /* RENAME */
127103 testcase( i==87 ); /* AFTER */
127104 testcase( i==88 ); /* REPLACE */
127105 testcase( i==89 ); /* AND */
127106 testcase( i==90 ); /* DEFAULT */
127107 testcase( i==91 ); /* AUTOINCREMENT */
127108 testcase( i==92 ); /* TO */
127109 testcase( i==93 ); /* IN */
127110 testcase( i==94 ); /* CAST */
127111 testcase( i==95 ); /* COLUMN */
127112 testcase( i==96 ); /* COMMIT */
127113 testcase( i==97 ); /* CONFLICT */
127114 testcase( i==98 ); /* CROSS */
127115 testcase( i==99 ); /* CURRENT_TIMESTAMP */
127116 testcase( i==100 ); /* CURRENT_TIME */
127117 testcase( i==101 ); /* PRIMARY */
127118 testcase( i==102 ); /* DEFERRED */
127119 testcase( i==103 ); /* DISTINCT */
127120 testcase( i==104 ); /* IS */
127121 testcase( i==105 ); /* DROP */
127122 testcase( i==106 ); /* FAIL */
127123 testcase( i==107 ); /* FROM */
127124 testcase( i==108 ); /* FULL */
127125 testcase( i==109 ); /* GLOB */
127126 testcase( i==110 ); /* BY */
127127 testcase( i==111 ); /* IF */
127128 testcase( i==112 ); /* ISNULL */
127129 testcase( i==113 ); /* ORDER */
127130 testcase( i==114 ); /* RESTRICT */
127131 testcase( i==115 ); /* RIGHT */
127132 testcase( i==116 ); /* ROLLBACK */
127133 testcase( i==117 ); /* ROW */
127134 testcase( i==118 ); /* UNION */
127135 testcase( i==119 ); /* USING */
127136 testcase( i==120 ); /* VACUUM */
127137 testcase( i==121 ); /* VIEW */
127138 testcase( i==122 ); /* INITIALLY */
127139 testcase( i==123 ); /* ALL */
127202 testcase( z[0]==' ' );
127203 testcase( z[0]=='\t' );
127204 testcase( z[0]=='\n' );
127205 testcase( z[0]=='\f' );
127206 testcase( z[0]=='\r' );
127319 testcase( delim=='`' );
127320 testcase( delim=='\'' );
127321 testcase( delim=='"' );
127355 testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
127356 testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
127357 testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
127358 testcase( z[0]=='9' );
127406 testcase( z[0]=='$' ); testcase( z[0]=='@' );
127407 testcase( z[0]==':' ); testcase( z[0]=='#' );
127435 testcase( z[0]=='x' ); testcase( z[0]=='X' );
129599 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
130099 testcase( db->pErr==0 );
130210 testcase( enc2==SQLITE_UTF16 );
130211 testcase( enc2==SQLITE_UTF16_ALIGNED );
130661 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
130662 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
130663 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
131127 testcase( sqlite3GlobalConfig.xLog!=0 );
131134 testcase( sqlite3GlobalConfig.xLog!=0 );
131141 testcase( sqlite3GlobalConfig.xLog!=0 );
132788 ** The testcase() macro is only used by the amalgamation. If undefined,
132791 #ifndef testcase
132792 # define testcase(X)
132848 ** within testcase() and assert() macros.
134961 testcase( c!=0 && (*pEnd)==0 );
135001 testcase( c!=0 && ((*pEnd)&0xfe)==0 );
139293 testcase(pCsr->filter.zTerm);