Lines Matching defs:testcase
13719 ** The testcase() macro is used to aid in coverage testing. When
13721 ** testcase() must be evaluated both true and false in order to
13722 ** get full branch coverage. The testcase() macro is inserted
13724 ** condition/decision coverage is inadequate. For example, testcase()
13726 ** bitmask tests, testcase() can be used to make sure each bit
13728 ** where multiple cases go to the same block of code, testcase()
13735 # define testcase(X) if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; }
13737 # define testcase(X)
13743 ** within testcase() and assert() macros.
13871 ** to fit in 32-bits. This macro is used inside of various testcase()
23345 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
23346 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
23347 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
25596 testcase( ROUND8(nByte)==nByte );
25599 testcase( sqlite3GlobalConfig.xLog!=0 );
25606 testcase( ROUND8(nByte)!=nByte );
25612 testcase( sqlite3GlobalConfig.xLog!=0 );
25669 testcase( sqlite3GlobalConfig.xLog!=0 );
25685 testcase( sqlite3GlobalConfig.xLog!=0 );
27230 testcase( sqlite3GlobalConfig.xLog!=0 );
29637 testcase( db==0 );
30250 testcase( wx>0x7fffffff );
30303 testcase( px>0x7fffffff );
30375 testcase( v==SMALLEST_INT64 );
30376 testcase( v==(-1) );
30483 testcase( precision>0xfff );
30916 testcase(p->accError==SQLITE_TOOBIG);
30917 testcase(p->accError==SQLITE_NOMEM);
30963 testcase( p->nChar + (i64)N > 0x7fffffff );
33665 testcase( rc );
34066 testcase( enc==SQLITE_UTF16LE );
34067 testcase( enc==SQLITE_UTF16BE );
34281 testcase( c==(-1) );
34282 testcase( c==0 );
34283 testcase( c==(+1) );
34340 testcase( i==18*incr );
34341 testcase( i==19*incr );
34342 testcase( i==20*incr );
34477 testcase( i==10 );
34481 testcase( v-neg==2147483647 );
34910 testcase( p[0]&0x80 );
35007 testcase( sqlite3GlobalConfig.xLog!=0 );
35021 testcase( sqlite3GlobalConfig.xLog!=0 );
35040 testcase( iA==0 ); testcase( iA==1 );
35041 testcase( iB==-1 ); testcase( iB==0 );
35043 testcase( iA>0 && LARGEST_INT64 - iA == iB );
35044 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
35047 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
35048 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
35059 testcase( iB==SMALLEST_INT64+1 );
35061 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
52127 testcase( iDb==1 );
57152 ** Use a testcase() macro to make sure that malloc failure within
57156 testcase( rc!=SQLITE_OK );
57304 testcase( rc==SQLITE_NOMEM );
57915 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
58185 testcase( (newSize-szPage) == currentSize );
58186 testcase( (newSize-szPage) > currentSize );
58483 testcase( rc!=SQLITE_OK );
58492 testcase( rc!=SQLITE_OK );
58501 testcase( rc!=SQLITE_OK );
58868 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
60141 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
60142 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
60143 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
60533 testcase( rc!=SQLITE_OK );
61127 testcase( rc==SQLITE_NOMEM );
61130 testcase( rc==SQLITE_NOMEM );
61541 testcase( rc==SQLITE_NOMEM );
61797 testcase( pPg->flags & PGHDR_NEED_SYNC );
64026 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
64439 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
64440 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
64441 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
64711 testcase( szPage<=32768 );
64712 testcase( szPage>=65536 );
65418 testcase( szPage<=32768 );
65419 testcase( szPage>=65536 );
65502 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
65506 testcase( IS_BIG_INT(iOffset) );
65518 testcase( IS_BIG_INT(szDb) );
65728 testcase( pWal->szPage<=32768 );
65729 testcase( pWal->szPage>=65536 );
65785 testcase( page0!=0 );
66418 testcase( (rc&0xff)==SQLITE_BUSY );
66419 testcase( (rc&0xff)==SQLITE_IOERR );
66420 testcase( rc==SQLITE_PROTOCOL );
66421 testcase( rc==SQLITE_OK );
66618 testcase( sz<=32768 );
66619 testcase( sz>=65536 );
66621 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
66845 testcase( (rc&0xff)==SQLITE_IOERR );
66846 testcase( rc==SQLITE_PROTOCOL );
66847 testcase( rc==SQLITE_OK );
67146 testcase( bSync );
67195 testcase( szPage<=32768 );
67196 testcase( szPage>=65536 );
67266 testcase( rc==SQLITE_BUSY );
67267 testcase( rc!=SQLITE_OK && xBusy2!=0 );
69406 testcase( p->iPage>=0 );
69752 testcase( surplus==maxLocal );
69753 testcase( surplus==maxLocal+1 );
69880 testcase( nPayload==pPage->maxLocal );
69881 testcase( nPayload==(u32)pPage->maxLocal+1 );
69917 testcase( nPayload==pPage->maxLocal );
69918 testcase( nPayload==(u32)pPage->maxLocal+1 );
69974 testcase( nSize==pPage->maxLocal );
69975 testcase( nSize==(u32)pPage->maxLocal+1 );
69982 testcase( nSize==pPage->maxLocal );
69983 testcase( nSize==(u32)pPage->maxLocal+1 );
70047 testcase( nSize==pPage->maxLocal );
70048 testcase( nSize==(u32)pPage->maxLocal+1 );
70055 testcase( nSize==pPage->maxLocal );
70056 testcase( nSize==(u32)pPage->maxLocal+1 );
70090 testcase( pSrc!=pPage );
70196 testcase( pc==iCellFirst );
70197 testcase( pc==iCellLast );
70211 testcase( cbrk+size==usableSize );
70212 testcase( pc+size==usableSize );
70265 testcase( x==4 );
70266 testcase( x==3 );
70358 testcase( gap+2==top );
70359 testcase( gap+1==top );
70360 testcase( gap==top );
70380 testcase( gap+2+nByte==top );
70702 testcase( pc==iCellFirst );
70703 testcase( pc==iCellLast );
70708 testcase( pc+sz==usableSize );
70758 testcase( pPage->nCell==MX_CELL(pBt) );
70944 testcase( pgno==0 );
72977 testcase( nPage==0 );
72979 testcase( pBt->nPage!=(u32)nPage );
73952 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
74154 testcase( pCur->ix!=pCur->pPage->nCell-1 );
74377 testcase( pCell+nCell+1==pPage->aDataEnd );
74384 testcase( pCell+nCell+2==pPage->aDataEnd );
74546 testcase( pCell+nCell+1==pPage->aDataEnd );
74553 testcase( pCell+nCell+2==pPage->aDataEnd );
74570 testcase( nCell<0 ); /* True if key size is 2^32 or more */
74571 testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */
74572 testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */
74573 testcase( nCell==2 ); /* Minimum legal index key size */
74901 testcase( n==mxPage-1 );
74957 testcase( iTrunk==mxPage );
75025 testcase( iNewTrunk==mxPage );
75085 testcase( iPage==mxPage );
75090 testcase( iPage==mxPage );
75357 testcase( pCell + pInfo->nSize == pPage->aDataEnd );
75358 testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
75485 testcase( n==3 );
75486 testcase( n==4 );
75490 testcase( nSrc<nPayload );
75501 testcase( n==pPage->maxLocal );
75502 testcase( n==pPage->maxLocal+1 );
75648 testcase( pc==(u32)get2byte(&data[hdr+5]) );
75649 testcase( pc+sz==pPage->pBt->usableSize );
77217 testcase( rc!=SQLITE_OK );
77675 testcase( pCur->eState==CURSOR_REQUIRESEEK );
77676 testcase( pCur->eState==CURSOR_FAULT );
77837 testcase( pCur->curFlags & BTCF_ValidOvfl );
78464 testcase( !pPage->intKey );
79398 testcase( pBt->db->flags & SQLITE_CellSizeCk );
79740 testcase( p->sharable );
80789 testcase( pMem->db==0 );
80794 testcase( bPreserve && pMem->z==0 );
80916 testcase( sqlite3_value_nochange(pMem) );
80945 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
80946 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
81069 testcase( p->flags & MEM_Dyn );
81175 testcase( flags & MEM_IntReal );
81205 testcase( pMem->flags & MEM_IntReal );
81220 testcase( pMem->flags & MEM_IntReal );
81320 testcase( pMem->flags & MEM_Int );
81321 testcase( pMem->flags & MEM_Real );
81322 testcase( pMem->flags & MEM_IntReal );
81323 testcase( pMem->flags & MEM_Null );
81747 testcase( nAlloc==0 );
81748 testcase( nAlloc==31 );
81749 testcase( nAlloc==32 );
82053 testcase( pCtx->pParse->rc==SQLITE_ERROR );
82054 testcase( pCtx->pParse->rc==SQLITE_OK );
82132 testcase( rc!=SQLITE_OK );
82168 testcase( pVal->flags & MEM_Int );
82169 testcase( pVal->flags & MEM_Real );
82445 testcase( iHdr==nHdr );
82446 testcase( iHdr==nHdr+1 );
82451 testcase( iField==nRec );
82452 testcase( iField==nRec+1 );
84572 testcase( p->flags & MEM_Agg );
84573 testcase( p->flags & MEM_Dyn );
84575 testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel );
86078 testcase( pAux->iAuxArg==31 );
86282 testcase( flags & MEM_Int );
86283 testcase( flags & MEM_IntReal );
86448 testcase( pMem->u.i<0 );
86494 testcase( pMem->u.i<0 );
86502 testcase( pMem->u.i<0 );
86510 testcase( pMem->u.i<0 );
86522 testcase( pMem->u.i<0 );
86530 testcase( pMem->u.i<0 );
86879 testcase( x<r );
86880 testcase( x>r );
86881 testcase( x==r );
86928 testcase( combined_flags & MEM_Int );
86929 testcase( combined_flags & MEM_Real );
86930 testcase( combined_flags & MEM_IntReal );
86932 testcase( f1 & f2 & MEM_Int );
86933 testcase( f1 & f2 & MEM_IntReal );
86944 testcase( f1 & MEM_Int );
86945 testcase( f1 & MEM_IntReal );
86958 testcase( f2 & MEM_Int );
86959 testcase( f2 & MEM_IntReal );
87014 testcase( aKey[0]&0x80 );
87017 testcase( aKey[0]&0x80 );
87020 testcase( aKey[0]&0x80 );
87023 testcase( aKey[0]&0x80 );
87028 testcase( aKey[0]&0x80 );
87033 testcase( aKey[0]&0x80 );
87117 testcase( pRhs->flags & MEM_Int );
87118 testcase( pRhs->flags & MEM_IntReal );
87120 testcase( serial_type==12 );
87167 testcase( serial_type==12 );
87174 testcase( (d1+mem1.n)==(unsigned)nKey1 );
87175 testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
87201 testcase( serial_type==12 );
87206 testcase( (d1+nStr)==(unsigned)nKey1 );
87207 testcase( (d1+nStr+1)==(unsigned)nKey1 );
87307 testcase( lhs<0 );
87312 testcase( lhs<0 );
87317 testcase( lhs<0 );
87323 testcase( lhs<0 );
87328 testcase( lhs<0 );
87335 testcase( lhs<0 );
87485 testcase( flags & MEM_Real );
87486 testcase( flags & MEM_Null );
87487 testcase( flags & MEM_Blob );
87535 testcase( szHdr==3 );
87536 testcase( szHdr==(u32)m.n );
87537 testcase( szHdr>0x7fffffff );
87546 testcase( typeRowid==1 );
87547 testcase( typeRowid==2 );
87548 testcase( typeRowid==3 );
87549 testcase( typeRowid==4 );
87550 testcase( typeRowid==5 );
87551 testcase( typeRowid==6 );
87552 testcase( typeRowid==8 );
87553 testcase( typeRowid==9 );
87558 testcase( (u32)m.n==szHdr+lenRowid );
87572 testcase( m.szMalloc!=0 );
88898 testcase( nByte<0 );
89877 testcase( pMem->flags & MEM_Int );
89878 testcase( pMem->flags & MEM_IntReal );
90193 testcase( zRawSql[0]==':' );
90194 testcase( zRawSql[0]=='$' );
90195 testcase( zRawSql[0]=='@' );
90196 testcase( zRawSql[0]=='#' );
90674 testcase( pRec->flags & MEM_Int );
90675 testcase( pRec->flags & MEM_Real );
90676 testcase( pRec->flags & MEM_IntReal );
90753 testcase( pMem->flags & MEM_Int );
90754 testcase( pMem->flags & MEM_Real );
90755 testcase( pMem->flags & MEM_IntReal );
90759 testcase( pMem->flags & MEM_Str );
90760 testcase( pMem->flags & MEM_Blob );
91086 testcase( p->rc!=SQLITE_OK );
91512 testcase( pOp->p5==1 );
91513 testcase( pOp->p5==2 );
91514 testcase( pOp->p5==3 );
91515 testcase( pOp->p5==4 );
92011 testcase( pOut==pIn2 );
92014 testcase( flags1 & MEM_Null );
92015 testcase( pIn2->flags & MEM_Null );
92345 testcase( pIn1->flags & MEM_Int );
92346 testcase( pIn1->flags & MEM_IntReal );
92372 testcase( pOp->p2==SQLITE_AFF_TEXT );
92373 testcase( pOp->p2==SQLITE_AFF_BLOB );
92374 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
92375 testcase( pOp->p2==SQLITE_AFF_INTEGER );
92376 testcase( pOp->p2==SQLITE_AFF_REAL );
92530 testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
92558 testcase( flags3==pIn3->flags );
92567 testcase( pIn1->flags & MEM_Int );
92568 testcase( pIn1->flags & MEM_Real );
92569 testcase( pIn1->flags & MEM_IntReal );
92571 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
92576 testcase( pIn3->flags & MEM_Int );
92577 testcase( pIn3->flags & MEM_Real );
92578 testcase( pIn3->flags & MEM_IntReal );
92580 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
93019 testcase( serialType==0 );
93020 testcase( serialType==1 );
93021 testcase( serialType==2 );
93022 testcase( serialType==3 );
93023 testcase( serialType==4 );
93024 testcase( serialType==5 );
93025 testcase( serialType==6 );
93026 testcase( serialType==7 );
93027 testcase( serialType==8 );
93028 testcase( serialType==9 );
93029 testcase( serialType==10 );
93030 testcase( serialType==11 );
93035 testcase( typeMask==0x01 );
93036 testcase( typeMask==0x02 );
93037 testcase( typeMask==0x04 );
93038 testcase( typeMask==0x08 );
93039 testcase( typeMask==0x10 );
93044 testcase( typeMask==0x01 );
93045 testcase( typeMask==0x02 );
93046 testcase( typeMask==0x04 );
93047 testcase( typeMask==0x08 );
93048 testcase( typeMask==0x10 );
93286 testcase( aOffset[0]==0 );
93319 testcase( zHdr>=zEndHdr );
93518 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real );
93519 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_IntReal );
93525 testcase( pIn1->u.i==140737488355328LL );
93526 testcase( pIn1->u.i==140737488355327LL );
93527 testcase( pIn1->u.i==-140737488355328LL );
93528 testcase( pIn1->u.i==-140737488355329LL );
93588 testcase( pIn1->u.i==140737488355328LL );
93589 testcase( pIn1->u.i==140737488355327LL );
93590 testcase( pIn1->u.i==-140737488355328LL );
93591 testcase( pIn1->u.i==-140737488355329LL );
93763 testcase( pRec->flags & MEM_Int );
93764 testcase( pRec->flags & MEM_IntReal );
93771 testcase( uu==127 ); testcase( uu==128 );
93772 testcase( uu==32767 ); testcase( uu==32768 );
93773 testcase( uu==8388607 ); testcase( uu==8388608 );
93774 testcase( uu==2147483647 ); testcase( uu==2147483648LL );
93775 testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL );
93839 testcase( nHdr==126 );
93840 testcase( nHdr==127 );
94286 testcase( rc==SQLITE_BUSY_SNAPSHOT );
94287 testcase( rc==SQLITE_BUSY_RECOVERY );
94600 testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */
94621 testcase( pOp->p5 & OPFLAG_BULKCSR );
94622 testcase( pOp->p2 & OPFLAG_SEEKEQ );
95264 testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
95651 testcase( pIn3->flags & MEM_Int );
95652 testcase( pIn3->flags & MEM_IntReal );
95653 testcase( pIn3->flags & MEM_Real );
95654 testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
96273 testcase( n==0 );
98605 testcase( pName->enc==SQLITE_UTF8 );
98606 testcase( pName->enc==SQLITE_UTF16BE );
98607 testcase( pName->enc==SQLITE_UTF16LE );
99196 testcase( sqlite3GlobalConfig.xLog!=0 );
99339 testcase( pC->nHdrParsed==p->iCol );
99340 testcase( pC->nHdrParsed==p->iCol+1 );
100395 testcase( rc!=SQLITE_OK );
100442 testcase( rc!=SQLITE_OK );
100474 testcase( rc!=SQLITE_OK );
100485 testcase( rc!=SQLITE_OK );
103481 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
103482 testcase( ExprHasProperty(pExpr, EP_Reduced) );
103846 testcase( pExTab->nCol==BMS-1 );
103847 testcase( pExTab->nCol==BMS );
103850 testcase( n==BMS-1 );
103851 testcase( n==BMS );
103943 testcase( pNC->ncFlags & NC_PartIdx );
103944 testcase( pNC->ncFlags & NC_IsCheck );
104165 testcase( iCol==(-1) );
104193 testcase( iCol==31 );
104194 testcase( iCol==32 );
104197 testcase( iCol==31 );
104198 testcase( iCol==32 );
104453 testcase( pTab->nCol==63 );
104454 testcase( pTab->nCol==64 );
104457 testcase( iCol==BMS );
104458 testcase( iCol==BMS-1 );
104594 testcase( ExprHasProperty(pExpr, EP_OuterON) );
104635 testcase( pNC->ncFlags & NC_IdxExpr );
104636 testcase( pNC->ncFlags & NC_GenCol );
104871 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
104872 testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 );
104887 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
104890 testcase( pExpr->op==TK_IN );
104893 testcase( pNC->ncFlags & NC_IsCheck );
104894 testcase( pNC->ncFlags & NC_PartIdx );
104895 testcase( pNC->ncFlags & NC_IdxExpr );
104896 testcase( pNC->ncFlags & NC_GenCol );
104911 testcase( pNC->ncFlags & NC_IsCheck );
104912 testcase( pNC->ncFlags & NC_PartIdx );
104913 testcase( pNC->ncFlags & NC_IdxExpr );
104914 testcase( pNC->ncFlags & NC_GenCol );
104958 testcase( pExpr->op==TK_EQ );
104959 testcase( pExpr->op==TK_NE );
104960 testcase( pExpr->op==TK_LT );
104961 testcase( pExpr->op==TK_LE );
104962 testcase( pExpr->op==TK_GT );
104963 testcase( pExpr->op==TK_GE );
104964 testcase( pExpr->op==TK_IS );
104965 testcase( pExpr->op==TK_ISNOT );
104966 testcase( pExpr->op==TK_BETWEEN );
105675 testcase( pNC->ncFlags & NC_HasAgg );
105676 testcase( pNC->ncFlags & NC_HasWin );
105717 testcase( pNC->ncFlags & NC_HasAgg );
105718 testcase( pNC->ncFlags & NC_HasWin );
106480 testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
106481 testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
106482 testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
106483 testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
106484 testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
106485 testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
106490 testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT);
106491 testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT);
106988 testcase( i==0 );
106989 testcase( i==1 );
106990 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
106991 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
107837 testcase( pEList && pEList->nExpr==mx );
107838 testcase( pEList && pEList->nExpr==mx+1 );
108026 testcase( pExpr->op==TK_ID );
108027 testcase( pExpr->op==TK_COLUMN );
108028 testcase( pExpr->op==TK_AGG_FUNCTION );
108029 testcase( pExpr->op==TK_AGG_COLUMN );
108040 testcase( pExpr->op==TK_REGISTER );
108041 testcase( pExpr->op==TK_IF_NULL_ROW );
108042 testcase( pExpr->op==TK_DOT );
108059 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
108060 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
108406 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
108407 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
108633 testcase( cmpaff==SQLITE_AFF_BLOB );
108634 testcase( cmpaff==SQLITE_AFF_TEXT );
108659 testcase( pIdx->nColumn==BMS-2 );
108660 testcase( pIdx->nColumn==BMS-1 );
108960 testcase( pSelect->selFlags & SF_Distinct );
108961 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
109075 testcase( pExpr->op==TK_EXISTS );
109076 testcase( pExpr->op==TK_SELECT );
109629 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
109634 testcase( x!=iCol );
110009 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
110142 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
110143 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
110144 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
110145 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
110146 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
110147 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
110153 testcase( regFree1==0 );
110154 testcase( regFree2==0 );
110170 assert( TK_AND==OP_And ); testcase( op==TK_AND );
110171 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
110172 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
110173 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
110174 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
110175 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
110176 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
110177 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
110178 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
110179 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
110180 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
110184 testcase( regFree1==0 );
110185 testcase( regFree2==0 );
110208 testcase( regFree2==0 );
110214 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
110215 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
110217 testcase( regFree1==0 );
110225 testcase( regFree1==0 );
110228 testcase( isTrue && bNormal);
110229 testcase( !isTrue && bNormal);
110236 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
110237 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
110240 testcase( regFree1==0 );
110310 testcase( i==31 );
110338 testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
110387 testcase( op==TK_EXISTS );
110388 testcase( op==TK_SELECT );
110616 testcase( pX->op==TK_COLUMN );
110618 testcase( regFree1==0 );
110637 testcase( pTest->op==TK_COLUMN );
110639 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
110980 testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1==0 );
110981 testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1!=0 );
110982 testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1==0 );
110983 testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1!=0 );
110984 testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1==0 );
110985 testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1!=0 );
110986 testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1==0 );
110987 testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1!=0 );
110988 testcase( xJump==0 );
111025 testcase( jumpIfNull==0 );
111031 testcase( jumpIfNull==0 );
111038 testcase( jumpIfNull==0 );
111045 testcase( jumpIfNull==0 );
111048 testcase( isTrue && isNot );
111049 testcase( !isTrue && isNot );
111061 testcase( op==TK_IS );
111062 testcase( op==TK_ISNOT );
111073 testcase( jumpIfNull==0 );
111078 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
111079 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
111080 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
111081 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
111082 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
111085 assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
111088 testcase( regFree1==0 );
111089 testcase( regFree2==0 );
111094 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
111095 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
111101 testcase( regFree1==0 );
111105 testcase( jumpIfNull==0 );
111129 testcase( regFree1==0 );
111130 testcase( jumpIfNull==0 );
111198 testcase( jumpIfNull==0 );
111203 testcase( jumpIfNull==0 );
111212 testcase( jumpIfNull==0 );
111219 testcase( jumpIfNull==0 );
111222 testcase( isTrue && isNot );
111223 testcase( !isTrue && isNot );
111238 testcase( pExpr->op==TK_IS );
111239 testcase( pExpr->op==TK_ISNOT );
111250 testcase( jumpIfNull==0 );
111255 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
111256 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
111257 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
111258 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
111259 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
111262 assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
111265 testcase( regFree1==0 );
111266 testcase( regFree2==0 );
111274 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
111275 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
111276 testcase( regFree1==0 );
111280 testcase( jumpIfNull==0 );
111306 testcase( regFree1==0 );
111307 testcase( jumpIfNull==0 );
111663 testcase( pExpr->op==TK_AGG_COLUMN );
111664 testcase( pExpr->op==TK_AGG_FUNCTION );
111677 testcase( pExpr->op==TK_ISNOT );
111678 testcase( pExpr->op==TK_ISNULL );
111679 testcase( pExpr->op==TK_NOTNULL );
111680 testcase( pExpr->op==TK_IS );
111681 testcase( pExpr->op==TK_OR );
111682 testcase( pExpr->op==TK_VECTOR );
111683 testcase( pExpr->op==TK_CASE );
111684 testcase( pExpr->op==TK_IN );
111685 testcase( pExpr->op==TK_FUNCTION );
111686 testcase( pExpr->op==TK_TRUTH );
111723 testcase( pExpr->op==TK_EQ );
111724 testcase( pExpr->op==TK_NE );
111725 testcase( pExpr->op==TK_LT );
111726 testcase( pExpr->op==TK_LE );
111727 testcase( pExpr->op==TK_GT );
111728 testcase( pExpr->op==TK_GE );
112075 testcase( pExpr->op==TK_AGG_COLUMN );
112076 testcase( pExpr->op==TK_COLUMN );
112077 testcase( pExpr->op==TK_IF_NULL_ROW );
113201 testcase( p->selFlags & SF_View );
113202 testcase( p->selFlags & SF_CopyCte );
113317 testcase( p->selFlags & SF_View );
113318 testcase( p->selFlags & SF_CopyCte );
113973 testcase( pSelect->selFlags & SF_View );
113974 testcase( pSelect->selFlags & SF_CopyCte );
117405 ** The following testcase() macros show that any of the 3rd through 6th
117407 testcase( zArg1==0 );
117408 testcase( zArg2==0 );
117409 testcase( zArg3==0 );
117410 testcase( pParse->zAuthContext==0 );
117919 testcase( pMod->pEpoTab==0 );
118349 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
118494 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
118495 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118497 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118499 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118939 testcase( pParse->earlyCleanup );
119222 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
119223 testcase( pCol->colFlags & COLFLAG_STORED );
119278 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
119279 testcase( pCol->colFlags & COLFLAG_STORED );
119627 testcase( pCol->affinity==SQLITE_AFF_BLOB );
119628 testcase( pCol->affinity==SQLITE_AFF_TEXT );
119629 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
119630 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
119631 testcase( pCol->affinity==SQLITE_AFF_REAL );
119735 testcase( pPk==pIdx );
119775 testcase( x==BMS-1 );
119776 testcase( x==BMS-2 );
119880 testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
119913 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
119925 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
120205 testcase( p->tabFlags & TF_HasVirtual );
120206 testcase( p->tabFlags & TF_HasStored );
120211 testcase( colFlags & COLFLAG_VIRTUAL );
120212 testcase( colFlags & COLFLAG_STORED );
121720 testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
124282 testcase( IsVirtual(pTab) );
124484 testcase( mask!=0xffffffff && iCol==31 );
124485 testcase( mask!=0xffffffff && iCol==32 );
124510 testcase( iIdxNoSeek>=0 );
124785 testcase( mask==0 );
125167 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
125168 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
125615 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
125616 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
126023 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
126024 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
128419 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
128420 testcase( pCol->colFlags & COLFLAG_STORED );
128892 testcase( pTab->tabFlags & TF_HasVirtual );
128893 testcase( pTab->tabFlags & TF_HasStored );
128932 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
128933 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
129036 testcase( pParse->earlyCleanup );
129602 testcase( pTab->tabFlags & TF_HasVirtual );
129603 testcase( pTab->tabFlags & TF_HasStored );
129606 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
129607 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
129855 testcase( pTab->tabFlags & TF_HasVirtual );
129856 testcase( pTab->tabFlags & TF_HasStored );
130103 testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
130106 testcase( w.eCode==0 );
130107 testcase( w.eCode==CKCNSTRNT_COLUMN );
130108 testcase( w.eCode==CKCNSTRNT_ROWID );
130109 testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
130366 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
130367 testcase( pCol->colFlags & COLFLAG_STORED );
130368 testcase( pCol->colFlags & COLFLAG_GENERATED );
130378 testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
130680 testcase( onError==OE_Rollback );
130681 testcase( onError==OE_Abort );
130682 testcase( onError==OE_Fail );
130740 testcase( onError==OE_Ignore );
130813 testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
130953 testcase( onError==OE_Rollback );
130954 testcase( onError==OE_Abort );
130955 testcase( onError==OE_Fail );
130966 testcase( onError==OE_Ignore );
130976 testcase( nConflictCk<=0 );
130977 testcase( nConflictCk>1 );
131064 testcase( regTrigCnt!=0 && nReplaceTrig==0 );
131468 testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */
131525 testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
131526 testcase( pDestCol->colFlags & COLFLAG_STORED );
136114 testcase( j!=sqlite3TableColumnToStorage(pTab, j) );
136118 testcase( p3!=j);
137759 ** testcase( pParse->earlyCleanup );
137885 testcase( db->flags & SQLITE_ReadUncommit );
137899 testcase( nBytes==mxLen );
137900 testcase( nBytes==mxLen+1 );
138497 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
138977 testcase( pKI->nAllField > pKI->nKeyField+2 );
139438 testcase( regOrig );
139439 testcase( eDest==SRT_Set );
139440 testcase( eDest==SRT_Mem );
139441 testcase( eDest==SRT_Coroutine );
139442 testcase( eDest==SRT_Output );
139523 testcase( eDest==SRT_Table );
139524 testcase( eDest==SRT_EphemTab );
139525 testcase( eDest==SRT_Fifo );
139526 testcase( eDest==SRT_DistFifo );
139636 testcase( eDest==SRT_Coroutine );
139637 testcase( eDest==SRT_Output );
140047 testcase( eDest==SRT_Output );
140048 testcase( eDest==SRT_Coroutine );
140434 testcase( aCol==0 );
140567 testcase( pCol->colFlags & COLFLAG_HASTYPE );
141150 testcase( rc!=SQLITE_OK );
141174 testcase( p->op==TK_EXCEPT );
141175 testcase( p->op==TK_UNION );
141223 testcase( rc!=SQLITE_OK );
141301 testcase( rc!=SQLITE_OK );
141495 testcase( pIn->nSdst>1 );
141511 testcase( pIn->nSdst>1 );
142034 testcase( ExprHasProperty(pExpr, EP_InnerON) );
142066 testcase( ExprHasProperty(pCopy, EP_Subquery) );
142591 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
142592 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
142611 testcase( pSub1->pSrc->nSrc>1 );
142654 testcase( i==SQLITE_DENY );
142752 testcase( pToplevel->earlyCleanup );
142993 testcase( ExprHasProperty(pExpr, EP_OuterON) );
142994 testcase( ExprHasProperty(pExpr, EP_InnerON) );
143033 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
143034 testcase( ExprHasProperty(pExpr, EP_OuterON) );
143035 testcase( ExprHasProperty(pExpr, EP_InnerON) );
143484 testcase( ExprHasProperty(pExpr, EP_Distinct) );
143485 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
144276 testcase( pX->zEName==0 );
144280 testcase( pX->zEName==0 );
144956 testcase( pParse->earlyCleanup );
145632 testcase( pParse->earlyCleanup );
146738 testcase( z==0 );
146878 testcase( pColumn );
146880 testcase( pUpsert );
148262 testcase( pPk!=0 && pPk!=pTab->pIndex );
148326 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
148327 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
148379 testcase( pTab->tabFlags & TF_HasVirtual );
148380 testcase( pTab->tabFlags & TF_HasStored );
148744 testcase( oldmask!=0xffffffff && i==31 );
148792 testcase( i==31 );
148793 testcase( i==32 );
148803 testcase( pTab->tabFlags & TF_HasVirtual );
148804 testcase( pTab->tabFlags & TF_HasStored );
148850 testcase( pTab->tabFlags & TF_HasVirtual );
148851 testcase( pTab->tabFlags & TF_HasStored );
152518 testcase( iEq==0 );
152519 testcase( bRev );
152559 testcase( bRev );
152610 testcase( iEq>0
152739 testcase( pIdx->aiColumn[j]==XN_EXPR );
152751 /* The following testcase is true for indices with redundant columns.
152753 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
152754 testcase( pTerm->wtFlags & TERM_VIRTUAL );
153101 testcase( x1!=x2 );
153211 testcase( pTerm->wtFlags & TERM_VIRTUAL );
153414 testcase( pOp->opcode==OP_Rowid );
153471 testcase( pTerm->wtFlags & TERM_VIRTUAL );
153527 testcase( pStart->wtFlags & TERM_VIRTUAL );
153530 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
153534 testcase( pX->op==TK_GT );
153535 testcase( pX->op==TK_GE );
153536 testcase( pX->op==TK_LT );
153537 testcase( pX->op==TK_LE );
153565 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
153566 testcase( pEnd->wtFlags & TERM_VIRTUAL );
153692 testcase( bRev );
153693 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
153720 testcase( pLoop->nSkip>0 );
153758 testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );
153759 testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 );
153760 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 );
153761 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 );
153782 testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
153839 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
153840 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
153841 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
153842 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
153843 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
153844 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
153856 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
153857 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
153858 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
153859 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
153896 testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
153926 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
153927 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
153928 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
153929 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
153944 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
153945 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
153946 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
153947 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
153984 testcase( pIdx->pPartIdxWhere );
154158 testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
154159 testcase( pWC->a[iTerm].wtFlags & TERM_CODED );
154160 testcase( pWC->a[iTerm].wtFlags & TERM_SLICE );
154191 testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
154389 testcase( pTerm->wtFlags & TERM_VIRTUAL );
154390 testcase( pTerm->wtFlags & TERM_CODED );
154393 testcase( pWInfo->untestedTerms==0
154495 testcase( pAlt->eOperator & WO_EQ );
154496 testcase( pAlt->eOperator & WO_IS );
154497 testcase( pAlt->eOperator & WO_IN );
154578 testcase( pTerm->wtFlags & TERM_VIRTUAL );
154579 testcase( pTerm->wtFlags & TERM_CODED );
154760 testcase( wtFlags & TERM_VIRTUAL );
155504 testcase( pOrTerm->wtFlags & TERM_COPIED );
155505 testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
155523 testcase( j==1 );
155583 testcase( idxNew==0 );
155891 testcase( (prereqLeft | extraRight) != prereqLeft );
155941 testcase( idxNew==0 );
156067 testcase( idxNew1==0 );
156075 testcase( idxNew2==0 );
156177 testcase( idxNew==0 );
156197 testcase( pTerm!=&pWC->a[idxTerm] );
156924 testcase( pTerm->eOperator & WO_IS );
157067 testcase( p->eOperator & WO_IS );
157314 testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LEFT );
157315 testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LTORJ );
157316 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
157317 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
157358 testcase( pTerm->pExpr->op==TK_IS );
157431 testcase( iCol==BMS );
157432 testcase( iCol==BMS-1 );
157463 testcase( pTable->nCol==BMS-1 );
157464 testcase( pTable->nCol==BMS-2 );
157487 testcase( iCol==BMS-1 );
157488 testcase( iCol==BMS );
157563 testcase( pParse->db->mallocFailed );
157753 testcase( pTerm->eOperator & WO_IN );
157754 testcase( pTerm->eOperator & WO_ISNULL );
157755 testcase( pTerm->eOperator & WO_IS );
157756 testcase( pTerm->eOperator & WO_ALL );
157883 testcase( j!=i );
158400 testcase( pRec->nField!=pBuilder->nRecValid );
159224 testcase( pTerm->pExpr->op==TK_IS );
159300 testcase( pLhs->iColumn==XN_ROWID );
159529 testcase( eOp & WO_GT );
159530 testcase( eOp & WO_GE );
159549 testcase( eOp & WO_LT );
159550 testcase( eOp & WO_LE );
159576 testcase( eOp & WO_IN );
159590 testcase( eOp & WO_EQ );
159591 testcase( eOp & WO_IS );
159592 testcase( eOp & WO_ISNULL );
160048 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
160304 testcase( pIdxInfo->needToFreeIdxStr );
160307 testcase( iTerm==nConstraint-1 );
160308 testcase( j==0 );
160309 testcase( j==pWC->nTerm-1 );
160315 testcase( iTerm==15 );
160316 testcase( iTerm==16 );
160319 testcase( i!=iTerm );
160322 testcase( i!=iTerm );
160365 testcase( pIdxInfo->needToFreeIdxStr );
160471 testcase( rc!=SQLITE_OK );
160751 testcase( rc==SQLITE_NOMEM && sCur.n>0 );
160752 testcase( rc==SQLITE_DONE );
160964 testcase( nOrderBy==BMS-1 );
161025 testcase( pTerm->pExpr->op==TK_IS );
161079 testcase( eOp & WO_ISNULL );
161080 testcase( eOp & WO_IS );
161081 testcase( isOrderDistinct );
161135 testcase( wctrlFlags & WHERE_GROUPBY );
161136 testcase( wctrlFlags & WHERE_DISTINCTBY );
161183 testcase( distinctColumns==0 );
161190 testcase( isOrderDistinct!=0 );
161197 testcase( isOrderDistinct==0 );
161496 testcase( jj==nTo-1 );
161562 testcase( pTo->rCost==rCost );
161565 testcase( pTo->rCost==rCost+1 );
161679 testcase( wsFlags & WHERE_IPK );
161680 testcase( wsFlags & WHERE_COLUMN_IN );
161747 testcase( pItem->fg.isIndexedBy );
161748 testcase( pItem->fg.notIndexed );
161759 testcase( pTerm->eOperator & WO_IS );
161779 testcase( pTerm->eOperator & WO_IS );
161998 testcase( pItem->fg.jointype & JT_LEFT );
162054 testcase( pTabItem->fg.jointype & JT_LEFT );
162055 testcase( pTabItem->fg.jointype & JT_RIGHT );
162056 testcase( pTabItem->fg.jointype & JT_LTORJ );
162210 testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
162216 testcase( pTabList->nSrc==BMS );
162571 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
162572 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
162996 testcase( pParse->db->mallocFailed );
163070 testcase( x!=sqlite3StorageColumnToTable(pTab,x) );
165336 testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
165337 testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt);
165338 testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le);
165339 testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt);
166265 ** Make yytestcase() the same as testcase()
166267 #define yytestcase(X) testcase(X)
169980 testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );
172141 testcase( i==0 ); /* REINDEX */
172142 testcase( i==1 ); /* INDEXED */
172143 testcase( i==2 ); /* INDEX */
172144 testcase( i==3 ); /* DESC */
172145 testcase( i==4 ); /* ESCAPE */
172146 testcase( i==5 ); /* EACH */
172147 testcase( i==6 ); /* CHECK */
172148 testcase( i==7 ); /* KEY */
172149 testcase( i==8 ); /* BEFORE */
172150 testcase( i==9 ); /* FOREIGN */
172151 testcase( i==10 ); /* FOR */
172152 testcase( i==11 ); /* IGNORE */
172153 testcase( i==12 ); /* REGEXP */
172154 testcase( i==13 ); /* EXPLAIN */
172155 testcase( i==14 ); /* INSTEAD */
172156 testcase( i==15 ); /* ADD */
172157 testcase( i==16 ); /* DATABASE */
172158 testcase( i==17 ); /* AS */
172159 testcase( i==18 ); /* SELECT */
172160 testcase( i==19 ); /* TABLE */
172161 testcase( i==20 ); /* LEFT */
172162 testcase( i==21 ); /* THEN */
172163 testcase( i==22 ); /* END */
172164 testcase( i==23 ); /* DEFERRABLE */
172165 testcase( i==24 ); /* ELSE */
172166 testcase( i==25 ); /* EXCLUDE */
172167 testcase( i==26 ); /* DELETE */
172168 testcase( i==27 ); /* TEMPORARY */
172169 testcase( i==28 ); /* TEMP */
172170 testcase( i==29 ); /* OR */
172171 testcase( i==30 ); /* ISNULL */
172172 testcase( i==31 ); /* NULLS */
172173 testcase( i==32 ); /* SAVEPOINT */
172174 testcase( i==33 ); /* INTERSECT */
172175 testcase( i==34 ); /* TIES */
172176 testcase( i==35 ); /* NOTNULL */
172177 testcase( i==36 ); /* NOT */
172178 testcase( i==37 ); /* NO */
172179 testcase( i==38 ); /* NULL */
172180 testcase( i==39 ); /* LIKE */
172181 testcase( i==40 ); /* EXCEPT */
172182 testcase( i==41 ); /* TRANSACTION */
172183 testcase( i==42 ); /* ACTION */
172184 testcase( i==43 ); /* ON */
172185 testcase( i==44 ); /* NATURAL */
172186 testcase( i==45 ); /* ALTER */
172187 testcase( i==46 ); /* RAISE */
172188 testcase( i==47 ); /* EXCLUSIVE */
172189 testcase( i==48 ); /* EXISTS */
172190 testcase( i==49 ); /* CONSTRAINT */
172191 testcase( i==50 ); /* INTO */
172192 testcase( i==51 ); /* OFFSET */
172193 testcase( i==52 ); /* OF */
172194 testcase( i==53 ); /* SET */
172195 testcase( i==54 ); /* TRIGGER */
172196 testcase( i==55 ); /* RANGE */
172197 testcase( i==56 ); /* GENERATED */
172198 testcase( i==57 ); /* DETACH */
172199 testcase( i==58 ); /* HAVING */
172200 testcase( i==59 ); /* GLOB */
172201 testcase( i==60 ); /* BEGIN */
172202 testcase( i==61 ); /* INNER */
172203 testcase( i==62 ); /* REFERENCES */
172204 testcase( i==63 ); /* UNIQUE */
172205 testcase( i==64 ); /* QUERY */
172206 testcase( i==65 ); /* WITHOUT */
172207 testcase( i==66 ); /* WITH */
172208 testcase( i==67 ); /* OUTER */
172209 testcase( i==68 ); /* RELEASE */
172210 testcase( i==69 ); /* ATTACH */
172211 testcase( i==70 ); /* BETWEEN */
172212 testcase( i==71 ); /* NOTHING */
172213 testcase( i==72 ); /* GROUPS */
172214 testcase( i==73 ); /* GROUP */
172215 testcase( i==74 ); /* CASCADE */
172216 testcase( i==75 ); /* ASC */
172217 testcase( i==76 ); /* DEFAULT */
172218 testcase( i==77 ); /* CASE */
172219 testcase( i==78 ); /* COLLATE */
172220 testcase( i==79 ); /* CREATE */
172221 testcase( i==80 ); /* CURRENT_DATE */
172222 testcase( i==81 ); /* IMMEDIATE */
172223 testcase( i==82 ); /* JOIN */
172224 testcase( i==83 ); /* INSERT */
172225 testcase( i==84 ); /* MATCH */
172226 testcase( i==85 ); /* PLAN */
172227 testcase( i==86 ); /* ANALYZE */
172228 testcase( i==87 ); /* PRAGMA */
172229 testcase( i==88 ); /* MATERIALIZED */
172230 testcase( i==89 ); /* DEFERRED */
172231 testcase( i==90 ); /* DISTINCT */
172232 testcase( i==91 ); /* IS */
172233 testcase( i==92 ); /* UPDATE */
172234 testcase( i==93 ); /* VALUES */
172235 testcase( i==94 ); /* VIRTUAL */
172236 testcase( i==95 ); /* ALWAYS */
172237 testcase( i==96 ); /* WHEN */
172238 testcase( i==97 ); /* WHERE */
172239 testcase( i==98 ); /* RECURSIVE */
172240 testcase( i==99 ); /* ABORT */
172241 testcase( i==100 ); /* AFTER */
172242 testcase( i==101 ); /* RENAME */
172243 testcase( i==102 ); /* AND */
172244 testcase( i==103 ); /* DROP */
172245 testcase( i==104 ); /* PARTITION */
172246 testcase( i==105 ); /* AUTOINCREMENT */
172247 testcase( i==106 ); /* TO */
172248 testcase( i==107 ); /* IN */
172249 testcase( i==108 ); /* CAST */
172250 testcase( i==109 ); /* COLUMN */
172251 testcase( i==110 ); /* COMMIT */
172252 testcase( i==111 ); /* CONFLICT */
172253 testcase( i==112 ); /* CROSS */
172254 testcase( i==113 ); /* CURRENT_TIMESTAMP */
172255 testcase( i==114 ); /* CURRENT_TIME */
172256 testcase( i==115 ); /* CURRENT */
172257 testcase( i==116 ); /* PRECEDING */
172258 testcase( i==117 ); /* FAIL */
172259 testcase( i==118 ); /* LAST */
172260 testcase( i==119 ); /* FILTER */
172261 testcase( i==120 ); /* REPLACE */
172262 testcase( i==121 ); /* FIRST */
172263 testcase( i==122 ); /* FOLLOWING */
172264 testcase( i==123 ); /* FROM */
172265 testcase( i==124 ); /* FULL */
172266 testcase( i==125 ); /* LIMIT */
172267 testcase( i==126 ); /* IF */
172268 testcase( i==127 ); /* ORDER */
172269 testcase( i==128 ); /* RESTRICT */
172270 testcase( i==129 ); /* OTHERS */
172271 testcase( i==130 ); /* OVER */
172272 testcase( i==131 ); /* RETURNING */
172273 testcase( i==132 ); /* RIGHT */
172274 testcase( i==133 ); /* ROLLBACK */
172275 testcase( i==134 ); /* ROWS */
172276 testcase( i==135 ); /* ROW */
172277 testcase( i==136 ); /* UNBOUNDED */
172278 testcase( i==137 ); /* UNION */
172279 testcase( i==138 ); /* USING */
172280 testcase( i==139 ); /* VACUUM */
172281 testcase( i==140 ); /* VIEW */
172282 testcase( i==141 ); /* WINDOW */
172283 testcase( i==142 ); /* DO */
172284 testcase( i==143 ); /* BY */
172285 testcase( i==144 ); /* INITIALLY */
172286 testcase( i==145 ); /* ALL */
172287 testcase( i==146 ); /* PRIMARY */
172443 testcase( z[0]==' ' );
172444 testcase( z[0]=='\t' );
172445 testcase( z[0]=='\n' );
172446 testcase( z[0]=='\f' );
172447 testcase( z[0]=='\r' );
172561 testcase( delim=='`' );
172562 testcase( delim=='\'' );
172563 testcase( delim=='"' );
172597 testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
172598 testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
172599 testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
172600 testcase( z[0]=='9' );
172644 testcase( z[0]=='$' ); testcase( z[0]=='@' );
172645 testcase( z[0]==':' ); testcase( z[0]=='#' );
172685 testcase( z[0]=='x' ); testcase( z[0]=='X' );
175359 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
175360 testcase( p->funcFlags & SQLITE_DIRECTONLY );
175948 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
175949 testcase( iDb==SQLITE_MAX_DB );
176019 testcase( db->pErr==0 );
176143 testcase( enc2==SQLITE_UTF16 );
176144 testcase( enc2==SQLITE_UTF16_ALIGNED );
176849 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
176850 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
176851 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
177198 testcase( sqlite3GlobalConfig.xLog!=0 );
177202 testcase( sqlite3GlobalConfig.xLog!=0 );
177206 testcase( sqlite3GlobalConfig.xLog!=0 );
177213 testcase( sqlite3GlobalConfig.xLog!=0 );
177219 testcase( sqlite3GlobalConfig.xLog!=0 );
177223 testcase( sqlite3GlobalConfig.xLog!=0 );
179394 ** The testcase() macro is only used by the amalgamation. If undefined,
179397 #ifndef testcase
179398 # define testcase(X)
179467 ** within testcase() and assert() macros.
181748 testcase( c!=0 && (*pEnd)==0 );
181788 testcase( c!=0 && ((*pEnd)&0xfe)==0 );
184600 testcase( a==0 ); /* If %_stat.value set to X'' */
186169 testcase(pCsr->filter.zTerm);
199366 testcase( nKey==0 );
199906 testcase( pTarget[j+1].eU==1 );
199907 testcase( pTarget[j+1].eU==2 );
199925 testcase( pParse->aNode[iRoot].eU==2 );
200074 testcase( pNode->eU!=0 && pNode->eU!=1 );
200132 testcase( pNode->eU!=0 && pNode->eU!=1 );
200492 testcase( pUp->eU==3 );
200568 testcase( pUp->eU==0 );
200711 testcase( iCol==0 );
201381 /* The testcase() macro should already be defined in the amalgamation. If
201387 # define testcase(X) if( X ){ sqlite3RtreeTestcase += __LINE__; }
201389 # define testcase(X)
203722 testcase( rc!=SQLITE_OK );
205655 testcase( pCtx==0 );
221966 #define testcase(x)
222842 ** Make fts5yytestcase() the same as testcase()
222844 #define fts5yytestcase(X) testcase(X)