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 );
43227 ** Use a testcase() macro to make sure that malloc failure within
43231 testcase( rc!=SQLITE_OK );
43379 testcase( rc==SQLITE_NOMEM );
43936 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
44196 testcase( (newSize-szPage) == currentSize );
44197 testcase( (newSize-szPage) > currentSize );
44484 testcase( rc!=SQLITE_OK );
44493 testcase( rc!=SQLITE_OK );
44500 testcase( rc!=SQLITE_OK );
44871 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
46061 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
46062 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
46063 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
46388 testcase( rc!=SQLITE_OK );
47043 testcase( rc==SQLITE_NOMEM );
47046 testcase( rc==SQLITE_NOMEM );
47398 testcase( rc==SQLITE_NOMEM );
49839 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
49840 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
49841 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
50097 testcase( szPage<=32768 );
50098 testcase( szPage>=65536 );
50629 testcase( szPage<=32768 );
50630 testcase( szPage>=65536 );
50708 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
50712 testcase( IS_BIG_INT(iOffset) );
50721 testcase( IS_BIG_INT(szDb) );
50923 testcase( pWal->szPage<=32768 );
50924 testcase( pWal->szPage>=65536 );
51256 testcase( (rc&0xff)==SQLITE_BUSY );
51257 testcase( (rc&0xff)==SQLITE_IOERR );
51258 testcase( rc==SQLITE_PROTOCOL );
51259 testcase( rc==SQLITE_OK );
51392 testcase( sz<=32768 );
51393 testcase( sz>=65536 );
51395 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
51607 testcase( (rc&0xff)==SQLITE_IOERR );
51608 testcase( rc==SQLITE_PROTOCOL );
51609 testcase( rc==SQLITE_OK );
51851 testcase( szPage<=32768 );
51852 testcase( szPage>=65536 );
51915 testcase( rc==SQLITE_BUSY );
51916 testcase( xBusy!=0 );
53757 testcase( p->iPage>0 );
54086 testcase( nPayload==pPage->maxLocal );
54087 testcase( nPayload==pPage->maxLocal+1 );
54113 testcase( surplus==maxLocal );
54114 testcase( surplus==maxLocal+1 );
54174 testcase( nSize==pPage->maxLocal );
54175 testcase( nSize==pPage->maxLocal+1 );
54182 testcase( nSize==pPage->maxLocal );
54183 testcase( nSize==pPage->maxLocal+1 );
54266 testcase( pc==iCellFirst );
54267 testcase( pc==iCellLast );
54289 testcase( cbrk+size==usableSize );
54290 testcase( pc+size==usableSize );
54350 testcase( x==4 );
54351 testcase( x==3 );
54421 testcase( gap+2==top );
54422 testcase( gap+1==top );
54423 testcase( gap==top );
54439 testcase( gap+2+nByte==top );
54670 testcase( pPage->nCell==MX_CELL(pBt) );
54694 testcase( pc==iCellFirst );
54695 testcase( pc==iCellLast );
54700 testcase( pc+sz==usableSize );
54888 testcase( pgno==0 );
56775 testcase( nPage==0 );
56777 testcase( pBt->nPage!=nPage );
57638 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
58004 testcase( pCell+nCell+1==pPage->aDataEnd );
58011 testcase( pCell+nCell+2==pPage->aDataEnd );
58157 testcase( idx>pPage->nCell );
58351 testcase( n==mxPage-1 );
58406 testcase( iTrunk==mxPage );
58474 testcase( iNewTrunk==mxPage );
58534 testcase( iPage==mxPage );
58539 testcase( iPage==mxPage );
58927 testcase( n==3 );
58928 testcase( n==4 );
58936 testcase( n==pPage->maxLocal );
58937 testcase( n==pPage->maxLocal+1 );
59082 testcase( pc==get2byte(&data[hdr+5]) );
59083 testcase( pc+sz==pPage->pBt->usableSize );
60347 testcase( rc!=SQLITE_OK );
63227 testcase( bPreserve && pMem->z==0 );
63364 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
63365 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
63469 testcase( p->flags & MEM_Dyn );
64003 testcase( nAlloc==0 );
64004 testcase( nAlloc==31 );
64005 testcase( nAlloc==32 );
64390 testcase( rc!=SQLITE_OK );
64725 testcase( iHdr==nHdr );
64726 testcase( iHdr==nHdr+1 );
64731 testcase( iField==nRec );
64732 testcase( iField==nRec+1 );
66084 testcase( p->flags & MEM_Agg );
66085 testcase( p->flags & MEM_Dyn );
66086 testcase( p->flags & MEM_Frame );
66087 testcase( p->flags & MEM_RowSet );
67496 testcase( pAux->iArg==31 );
67866 testcase( pMem->u.i<0 );
67907 testcase( pMem->u.i<0 );
67915 testcase( pMem->u.i<0 );
67923 testcase( pMem->u.i<0 );
67931 testcase( pMem->u.i<0 );
67939 testcase( pMem->u.i<0 );
68346 testcase( aKey[0]&0x80 );
68349 testcase( aKey[0]&0x80 );
68352 testcase( aKey[0]&0x80 );
68355 testcase( aKey[0]&0x80 );
68360 testcase( aKey[0]&0x80 );
68365 testcase( aKey[0]&0x80 );
68442 testcase( serial_type==12 );
68493 testcase( serial_type==12 );
68500 testcase( (d1+mem1.n)==(unsigned)nKey1 );
68501 testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
68524 testcase( serial_type==12 );
68529 testcase( (d1+nStr)==(unsigned)nKey1 );
68530 testcase( (d1+nStr+1)==(unsigned)nKey1 );
68611 testcase( lhs<0 );
68616 testcase( lhs<0 );
68621 testcase( lhs<0 );
68627 testcase( lhs<0 );
68632 testcase( lhs<0 );
68639 testcase( lhs<0 );
68771 testcase( flags & MEM_Real );
68772 testcase( flags & MEM_Null );
68773 testcase( flags & MEM_Blob );
68818 testcase( szHdr==3 );
68819 testcase( szHdr==m.n );
68827 testcase( typeRowid==1 );
68828 testcase( typeRowid==2 );
68829 testcase( typeRowid==3 );
68830 testcase( typeRowid==4 );
68831 testcase( typeRowid==5 );
68832 testcase( typeRowid==6 );
68833 testcase( typeRowid==8 );
68834 testcase( typeRowid==9 );
68839 testcase( (u32)m.n==szHdr+lenRowid );
68853 testcase( m.szMalloc!=0 );
69702 testcase( nByte<0 );
70689 testcase( zRawSql[0]==':' );
70690 testcase( zRawSql[0]=='$' );
70691 testcase( zRawSql[0]=='@' );
70692 testcase( zRawSql[0]=='#' );
71810 testcase( pOp->p5==1 );
71811 testcase( pOp->p5==2 );
71812 testcase( pOp->p5==3 );
71813 testcase( pOp->p5==4 );
72635 testcase( pOp->p2==SQLITE_AFF_TEXT );
72636 testcase( pOp->p2==SQLITE_AFF_NONE );
72637 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
72638 testcase( pOp->p2==SQLITE_AFF_INTEGER );
72639 testcase( pOp->p2==SQLITE_AFF_REAL );
72793 testcase( pIn1->flags & MEM_Int );
72794 testcase( pIn1->flags & MEM_Real );
72796 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
72800 testcase( pIn3->flags & MEM_Int );
72801 testcase( pIn3->flags & MEM_Real );
72803 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
73526 testcase( serial_type==127 );
73527 testcase( serial_type==128 );
73535 testcase( nHdr==126 );
73536 testcase( nHdr==127 );
74197 testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */
75278 testcase( n==0 );
75551 testcase( res==1 );
77141 testcase( pName->enc==SQLITE_UTF8 );
77142 testcase( pName->enc==SQLITE_UTF16BE );
77143 testcase( pName->enc==SQLITE_UTF16LE );
77382 testcase( sqlite3GlobalConfig.xLog!=0 );
77397 testcase( nVmStep>0 );
78535 testcase( rc!=SQLITE_OK );
78582 testcase( rc!=SQLITE_OK );
78614 testcase( rc!=SQLITE_OK );
78625 testcase( rc!=SQLITE_OK );
81200 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
81201 testcase( ExprHasProperty(pExpr, EP_Reduced) );
81560 testcase( pNC->ncFlags & NC_PartIdx );
81561 testcase( pNC->ncFlags & NC_IsCheck );
81685 testcase( iCol==31 );
81686 testcase( iCol==32 );
81689 testcase( iCol==31 );
81690 testcase( iCol==32 );
81805 testcase( n==BMS-1 );
81854 testcase( iCol==BMS );
81855 testcase( iCol==BMS-1 );
82084 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
82097 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
82100 testcase( pExpr->op==TK_IN );
83493 testcase( i==0 );
83494 testcase( i==1 );
83495 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
83496 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
84042 testcase( pEList && pEList->nExpr==mx );
84043 testcase( pEList && pEList->nExpr==mx+1 );
84132 testcase( pExpr->op==TK_ID );
84133 testcase( pExpr->op==TK_COLUMN );
84134 testcase( pExpr->op==TK_AGG_FUNCTION );
84135 testcase( pExpr->op==TK_AGG_COLUMN );
84156 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
84157 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
84364 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
84365 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
84730 testcase( pSelect->selFlags & SF_Distinct );
84731 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
84820 testcase( pExpr->op==TK_EXISTS );
84821 testcase( pExpr->op==TK_SELECT );
85361 ** This routine is used within assert() and testcase() macros only
85515 testcase( usedAsColumnCache(pParse, inReg, inReg) );
85530 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
85531 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
85532 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
85533 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
85534 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
85535 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
85536 testcase( regFree1==0 );
85537 testcase( regFree2==0 );
85542 testcase( op==TK_IS );
85543 testcase( op==TK_ISNOT );
85551 testcase( regFree1==0 );
85552 testcase( regFree2==0 );
85567 assert( TK_AND==OP_And ); testcase( op==TK_AND );
85568 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
85569 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
85570 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
85571 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
85572 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
85573 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
85574 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
85575 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
85576 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
85577 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
85581 testcase( regFree1==0 );
85582 testcase( regFree2==0 );
85602 testcase( regFree2==0 );
85609 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
85610 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
85612 testcase( regFree1==0 );
85620 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
85621 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
85624 testcase( regFree1==0 );
85700 testcase( i==31 );
85728 testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
85775 testcase( op==TK_EXISTS );
85776 testcase( op==TK_SELECT );
85812 testcase( regFree1==0 );
85813 testcase( regFree2==0 );
85822 testcase( regFree2==0 );
85934 testcase( pX->op==TK_COLUMN );
85936 testcase( regFree1==0 );
85955 testcase( pTest->op==TK_COLUMN );
85957 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
86492 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
86493 testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
86494 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
86495 testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
86496 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
86497 testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
86498 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
86499 testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
86530 testcase( jumpIfNull==0 );
86539 testcase( jumpIfNull==0 );
86547 testcase( jumpIfNull==0 );
86557 testcase( jumpIfNull==0 );
86562 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86563 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86564 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86565 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86566 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86567 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86568 testcase( regFree1==0 );
86569 testcase( regFree2==0 );
86574 testcase( op==TK_IS );
86575 testcase( op==TK_ISNOT );
86583 testcase( regFree1==0 );
86584 testcase( regFree2==0 );
86589 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
86590 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
86595 testcase( regFree1==0 );
86599 testcase( jumpIfNull==0 );
86622 testcase( regFree1==0 );
86623 testcase( jumpIfNull==0 );
86685 testcase( jumpIfNull==0 );
86694 testcase( jumpIfNull==0 );
86703 testcase( jumpIfNull==0 );
86713 testcase( jumpIfNull==0 );
86718 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86719 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86720 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86721 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86722 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86723 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86724 testcase( regFree1==0 );
86725 testcase( regFree2==0 );
86730 testcase( pExpr->op==TK_IS );
86731 testcase( pExpr->op==TK_ISNOT );
86739 testcase( regFree1==0 );
86740 testcase( regFree2==0 );
86747 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
86748 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
86749 testcase( regFree1==0 );
86753 testcase( jumpIfNull==0 );
86778 testcase( regFree1==0 );
86779 testcase( jumpIfNull==0 );
87024 testcase( pExpr->op==TK_AGG_COLUMN );
87025 testcase( pExpr->op==TK_COLUMN );
91479 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
92390 testcase( pCol->affinity==SQLITE_AFF_NONE );
92391 testcase( pCol->affinity==SQLITE_AFF_TEXT );
92392 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
92393 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
92394 testcase( pCol->affinity==SQLITE_AFF_REAL );
96071 testcase( IsVirtual(pTab) );
96244 testcase( mask!=0xffffffff && iCol==31 );
96245 testcase( mask!=0xffffffff && iCol==32 );
96506 testcase( mask==0 );
96843 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
96844 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
97250 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
97251 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
97574 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
97575 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
97642 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
97643 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
106190 testcase( db->flags & SQLITE_ReadUncommitted );
106203 testcase( nBytes==mxLen );
106204 testcase( nBytes==mxLen+1 );
106707 testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
107030 testcase( pKI->nXField>2 );
107297 testcase( eDest==SRT_Table );
107298 testcase( eDest==SRT_EphemTab );
107377 testcase( eDest==SRT_Coroutine );
107378 testcase( eDest==SRT_Output );
107716 testcase( eDest==SRT_Table );
107717 testcase( eDest==SRT_EphemTab );
107741 testcase( eDest==SRT_Output );
107742 testcase( eDest==SRT_Coroutine );
107828 testcase( pExpr->op==TK_AGG_COLUMN );
107829 testcase( pExpr->op==TK_COLUMN );
108080 testcase( aCol==0 );
108760 testcase( rc!=SQLITE_OK );
108784 testcase( p->op==TK_EXCEPT );
108785 testcase( p->op==TK_UNION );
108833 testcase( rc!=SQLITE_OK );
108917 testcase( rc!=SQLITE_OK );
109073 testcase( pDest->eDest==SRT_Table );
109074 testcase( pDest->eDest==SRT_EphemTab );
109117 assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 );
109351 testcase( pItem->u.x.iOrderByCol > p->pEList->nExpr );
109860 testcase( pSub->selFlags & SF_Recursive );
109861 testcase( pSub->selFlags & SF_MinMaxAgg );
109918 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
109919 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
109928 testcase( pSub1->pSrc->nSrc>1 );
109947 testcase( i==SQLITE_DENY );
110844 testcase( pX->zSpan==0 );
110848 testcase( pX->zSpan==0 );
111098 testcase( nArg==0 ); /* Error condition */
111099 testcase( nArg>1 ); /* Also an error */
113895 testcase( oldmask!=0xffffffff && i==31 );
113936 testcase( i==31 );
113937 testcase( i==32 );
116400 testcase( wtFlags & TERM_VIRTUAL );
117185 testcase( db->mallocFailed );
117285 testcase( pOrTerm->wtFlags & TERM_COPIED );
117286 testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
117302 testcase( j==1 );
117358 testcase( idxNew==0 );
117481 testcase( (prereqLeft | extraRight) != prereqLeft );
117518 testcase( idxNew==0 );
117603 testcase( idxNew1==0 );
117611 testcase( idxNew2==0 );
117643 testcase( idxNew==0 );
117942 testcase( iCol==BMS );
117943 testcase( iCol==BMS-1 );
117974 testcase( pTable->nCol==BMS-1 );
117975 testcase( pTable->nCol==BMS-2 );
117995 testcase( iCol==BMS-1 );
117996 testcase( iCol==BMS );
118089 testcase( pTerm->eOperator & WO_IN );
118090 testcase( pTerm->eOperator & WO_ISNULL );
118091 testcase( pTerm->eOperator & WO_ALL );
118142 testcase( pTerm->eOperator & WO_IN );
118143 testcase( pTerm->eOperator & WO_ISNULL );
118144 testcase( pTerm->eOperator & WO_ALL );
118632 testcase( pRec->nField!=pBuilder->nRecValid );
119003 testcase( iEq==0 );
119004 testcase( bRev );
119011 testcase( bRev );
119155 /* The following testcase is true for indices with redundant columns.
119157 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
119158 testcase( pTerm->wtFlags & TERM_VIRTUAL );
119168 testcase( pTerm->eOperator & WO_ISNULL );
119169 testcase( pTerm->eOperator & WO_IN );
119561 testcase( pTerm->wtFlags & TERM_VIRTUAL );
119612 testcase( pStart->wtFlags & TERM_VIRTUAL );
119615 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
119636 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
119637 testcase( pEnd->wtFlags & TERM_VIRTUAL );
119770 testcase( bRev );
119771 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
119807 testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );
119808 testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 );
119809 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 );
119810 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 );
119839 testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
119851 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
119852 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
119853 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
119854 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
119855 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
119856 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
119879 testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
119894 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
119895 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
119896 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
119897 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
120079 testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
120258 testcase( pTerm->wtFlags & TERM_VIRTUAL );
120259 testcase( pTerm->wtFlags & TERM_CODED );
120262 testcase( pWInfo->untestedTerms==0
120303 testcase( pAlt->eOperator & WO_EQ );
120304 testcase( pAlt->eOperator & WO_IN );
120324 testcase( pTerm->wtFlags & TERM_VIRTUAL );
120325 testcase( pTerm->wtFlags & TERM_CODED );
120992 testcase( eOp & WO_GT );
120993 testcase( eOp & WO_GE );
121010 testcase( eOp & WO_LT );
121011 testcase( eOp & WO_LE );
121035 testcase( eOp & WO_IN );
121048 testcase( eOp & WO_EQ );
121049 testcase( eOp & WO_ISNULL );
121194 testcase( x==BMS-1 );
121195 testcase( x==BMS-2 );
121370 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
121565 testcase( iTerm==nConstraint-1 );
121566 testcase( j==0 );
121567 testcase( j==pWC->nTerm-1 );
121573 testcase( iTerm==15 );
121574 testcase( iTerm==16 );
121859 testcase( nOrderBy==BMS-1 );
121929 testcase( isOrderDistinct );
121966 testcase( wctrlFlags & WHERE_GROUPBY );
121967 testcase( wctrlFlags & WHERE_DISTINCTBY );
121993 testcase( distinctColumns==0 );
122000 testcase( isOrderDistinct!=0 );
122007 testcase( isOrderDistinct==0 );
122278 testcase( jj==nTo-1 );
122334 testcase( pTo->rCost==rCost );
122337 testcase( pTo->rCost==rCost+1 );
122666 testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
122679 testcase( pTabList->nSrc==BMS );
122954 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
122955 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
123272 ** Make yytestcase() the same as testcase()
123274 #define yytestcase(X) testcase(X)
127034 testcase( i==0 ); /* REINDEX */
127035 testcase( i==1 ); /* INDEXED */
127036 testcase( i==2 ); /* INDEX */
127037 testcase( i==3 ); /* DESC */
127038 testcase( i==4 ); /* ESCAPE */
127039 testcase( i==5 ); /* EACH */
127040 testcase( i==6 ); /* CHECK */
127041 testcase( i==7 ); /* KEY */
127042 testcase( i==8 ); /* BEFORE */
127043 testcase( i==9 ); /* FOREIGN */
127044 testcase( i==10 ); /* FOR */
127045 testcase( i==11 ); /* IGNORE */
127046 testcase( i==12 ); /* REGEXP */
127047 testcase( i==13 ); /* EXPLAIN */
127048 testcase( i==14 ); /* INSTEAD */
127049 testcase( i==15 ); /* ADD */
127050 testcase( i==16 ); /* DATABASE */
127051 testcase( i==17 ); /* AS */
127052 testcase( i==18 ); /* SELECT */
127053 testcase( i==19 ); /* TABLE */
127054 testcase( i==20 ); /* LEFT */
127055 testcase( i==21 ); /* THEN */
127056 testcase( i==22 ); /* END */
127057 testcase( i==23 ); /* DEFERRABLE */
127058 testcase( i==24 ); /* ELSE */
127059 testcase( i==25 ); /* EXCEPT */
127060 testcase( i==26 ); /* TRANSACTION */
127061 testcase( i==27 ); /* ACTION */
127062 testcase( i==28 ); /* ON */
127063 testcase( i==29 ); /* NATURAL */
127064 testcase( i==30 ); /* ALTER */
127065 testcase( i==31 ); /* RAISE */
127066 testcase( i==32 ); /* EXCLUSIVE */
127067 testcase( i==33 ); /* EXISTS */
127068 testcase( i==34 ); /* SAVEPOINT */
127069 testcase( i==35 ); /* INTERSECT */
127070 testcase( i==36 ); /* TRIGGER */
127071 testcase( i==37 ); /* REFERENCES */
127072 testcase( i==38 ); /* CONSTRAINT */
127073 testcase( i==39 ); /* INTO */
127074 testcase( i==40 ); /* OFFSET */
127075 testcase( i==41 ); /* OF */
127076 testcase( i==42 ); /* SET */
127077 testcase( i==43 ); /* TEMPORARY */
127078 testcase( i==44 ); /* TEMP */
127079 testcase( i==45 ); /* OR */
127080 testcase( i==46 ); /* UNIQUE */
127081 testcase( i==47 ); /* QUERY */
127082 testcase( i==48 ); /* WITHOUT */
127083 testcase( i==49 ); /* WITH */
127084 testcase( i==50 ); /* OUTER */
127085 testcase( i==51 ); /* RELEASE */
127086 testcase( i==52 ); /* ATTACH */
127087 testcase( i==53 ); /* HAVING */
127088 testcase( i==54 ); /* GROUP */
127089 testcase( i==55 ); /* UPDATE */
127090 testcase( i==56 ); /* BEGIN */
127091 testcase( i==57 ); /* INNER */
127092 testcase( i==58 ); /* RECURSIVE */
127093 testcase( i==59 ); /* BETWEEN */
127094 testcase( i==60 ); /* NOTNULL */
127095 testcase( i==61 ); /* NOT */
127096 testcase( i==62 ); /* NO */
127097 testcase( i==63 ); /* NULL */
127098 testcase( i==64 ); /* LIKE */
127099 testcase( i==65 ); /* CASCADE */
127100 testcase( i==66 ); /* ASC */
127101 testcase( i==67 ); /* DELETE */
127102 testcase( i==68 ); /* CASE */
127103 testcase( i==69 ); /* COLLATE */
127104 testcase( i==70 ); /* CREATE */
127105 testcase( i==71 ); /* CURRENT_DATE */
127106 testcase( i==72 ); /* DETACH */
127107 testcase( i==73 ); /* IMMEDIATE */
127108 testcase( i==74 ); /* JOIN */
127109 testcase( i==75 ); /* INSERT */
127110 testcase( i==76 ); /* MATCH */
127111 testcase( i==77 ); /* PLAN */
127112 testcase( i==78 ); /* ANALYZE */
127113 testcase( i==79 ); /* PRAGMA */
127114 testcase( i==80 ); /* ABORT */
127115 testcase( i==81 ); /* VALUES */
127116 testcase( i==82 ); /* VIRTUAL */
127117 testcase( i==83 ); /* LIMIT */
127118 testcase( i==84 ); /* WHEN */
127119 testcase( i==85 ); /* WHERE */
127120 testcase( i==86 ); /* RENAME */
127121 testcase( i==87 ); /* AFTER */
127122 testcase( i==88 ); /* REPLACE */
127123 testcase( i==89 ); /* AND */
127124 testcase( i==90 ); /* DEFAULT */
127125 testcase( i==91 ); /* AUTOINCREMENT */
127126 testcase( i==92 ); /* TO */
127127 testcase( i==93 ); /* IN */
127128 testcase( i==94 ); /* CAST */
127129 testcase( i==95 ); /* COLUMN */
127130 testcase( i==96 ); /* COMMIT */
127131 testcase( i==97 ); /* CONFLICT */
127132 testcase( i==98 ); /* CROSS */
127133 testcase( i==99 ); /* CURRENT_TIMESTAMP */
127134 testcase( i==100 ); /* CURRENT_TIME */
127135 testcase( i==101 ); /* PRIMARY */
127136 testcase( i==102 ); /* DEFERRED */
127137 testcase( i==103 ); /* DISTINCT */
127138 testcase( i==104 ); /* IS */
127139 testcase( i==105 ); /* DROP */
127140 testcase( i==106 ); /* FAIL */
127141 testcase( i==107 ); /* FROM */
127142 testcase( i==108 ); /* FULL */
127143 testcase( i==109 ); /* GLOB */
127144 testcase( i==110 ); /* BY */
127145 testcase( i==111 ); /* IF */
127146 testcase( i==112 ); /* ISNULL */
127147 testcase( i==113 ); /* ORDER */
127148 testcase( i==114 ); /* RESTRICT */
127149 testcase( i==115 ); /* RIGHT */
127150 testcase( i==116 ); /* ROLLBACK */
127151 testcase( i==117 ); /* ROW */
127152 testcase( i==118 ); /* UNION */
127153 testcase( i==119 ); /* USING */
127154 testcase( i==120 ); /* VACUUM */
127155 testcase( i==121 ); /* VIEW */
127156 testcase( i==122 ); /* INITIALLY */
127157 testcase( i==123 ); /* ALL */
127220 testcase( z[0]==' ' );
127221 testcase( z[0]=='\t' );
127222 testcase( z[0]=='\n' );
127223 testcase( z[0]=='\f' );
127224 testcase( z[0]=='\r' );
127337 testcase( delim=='`' );
127338 testcase( delim=='\'' );
127339 testcase( delim=='"' );
127373 testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
127374 testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
127375 testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
127376 testcase( z[0]=='9' );
127424 testcase( z[0]=='$' ); testcase( z[0]=='@' );
127425 testcase( z[0]==':' ); testcase( z[0]=='#' );
127453 testcase( z[0]=='x' ); testcase( z[0]=='X' );
129617 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
130117 testcase( db->pErr==0 );
130228 testcase( enc2==SQLITE_UTF16 );
130229 testcase( enc2==SQLITE_UTF16_ALIGNED );
130679 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
130680 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
130681 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
131145 testcase( sqlite3GlobalConfig.xLog!=0 );
131152 testcase( sqlite3GlobalConfig.xLog!=0 );
131159 testcase( sqlite3GlobalConfig.xLog!=0 );
132806 ** The testcase() macro is only used by the amalgamation. If undefined,
132809 #ifndef testcase
132810 # define testcase(X)
132866 ** within testcase() and assert() macros.
134979 testcase( c!=0 && (*pEnd)==0 );
135019 testcase( c!=0 && ((*pEnd)&0xfe)==0 );
139323 testcase(pCsr->filter.zTerm);