Mastering Visual Basic 6/mastvb6.iso/numega/sc501.exe/data1.cab/Examples/APIERR.CPP

C/C++ Source or Header | 1997-11-25 | 10.2 KB | 454 lines

/*
 * APIErr.cpp
 * $Header: /BoundsChecker/Examples/BUGBNCHX/MAINERR/APIERR.CPP 7     2/03/97 7:13p Stevea $
 *
 * Description:
 *  The functions that cause the API Check errors.
 *
 * Notes:
 *  <implementation notes go here>
 *
 ***********************************************************************
 *
 * Nu-Mega Technologies, Inc.
 * P.O. Box 7780
 * Nashua, NH 03060
 *
 * (c) Copyright 1994, 1995 Nu-Mega Technologies, Inc.
 * ALL RIGHTS RESERVED.
 *
 ***********************************************************************
 *
 **********************************************************************/
#include "stdafx.h"
#include "APIErr.h"

// API Check - API failure: Windows function failed
void API_Failure_LoadBitmap ( )
{
   _TRY
   {
      HBITMAP hBitmap = LoadBitmap (  GetModuleHandle ( NULL ) ,
                                      _T ( "HappyBitmap" )      ) ;
   }
   _CATCH
   {
   }
}
void API_Failure_Malloc ( )
{
   _TRY
   {
      char * pchBuff ;
      pchBuff = (char*)malloc ( 0x7FFFFFFF ) ;
   }
   _CATCH
   {
   }
}
// API Check - API failure: Windows function not implemented
void API_Failure_PaintDesktop ( )
{
   _TRY
   {
      HDC hDC;

      hDC = GetDC ( GetDesktopWindow ( ) ) ;
      PaintDesktop( hDC );
      ReleaseDC ( GetDesktopWindow ( ) , hDC ) ;
   }
   _CATCH
   {
   }
}

void API_Failure_HeapValidate ( )
{
   _TRY
   {
      wchar_t * wszText = L"Wide Chars" ;
      ATOM hAtom = AddAtomW ( wszText ) ;
      if ( 0 != hAtom )
      {
         DeleteAtom ( hAtom ) ;
      }
   }
   _CATCH
   {
   }
}
// API Check - Freed handle is still locked"
void API_FreedHandleStillLocked ( )
{
   _TRY
   {
      HANDLE hMem    ;
      LPVOID lpMem   ;

      hMem  = GlobalAlloc ( GHND , 0x100 ) ;
      lpMem = GlobalLock ( hMem ) ;

      GlobalFree ( hMem ) ;

   }
   _CATCH
   {
   }
}
// API Check - Handle is already unlocked
void API_HandleAlreadyUnlocked ( )
{
   _TRY
   {
      HANDLE hMem;
      hMem = GlobalAlloc ( GHND , 0x100 ) ;
      GlobalUnlock ( hMem ) ;
      GlobalFree ( hMem ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: At least one format specifier is
//             illegal
void API_IllegalFormatSpec ( )
{
   _TRY
   {
      TCHAR szBuffer[ 100 ] ;
      wsprintf ( szBuffer , _T ( "Pi = %f" ) , 3.141592 ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Bad destination pointer
void API_BadDestPtr ( )
{
   _TRY
   {
      TCHAR buffer[ 20 ] ;
      // This will also be a instrument compile error as well but it
      //  only will make a single popup error.
      strncpy ( NULL , buffer , 10 ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Bad handle
void API_BadHandleFree ( )
{
   _TRY
   {
      char * pchChar = (char*)0x10 ;
      free ( pchChar ) ;
   }
   _CATCH
   {
   }
}
void API_BadHandleLocalFree ( )
{
   _TRY
   {
      HANDLE ptr = (HANDLE)0x10 ;
      LocalFree ( ptr ) ;
   }
   _CATCH
   {
   }
}
void API_BadHandleRealloc ( )
{
   _TRY
   {
      char * pchChar = (char*)0x10 ;
      pchChar = (char*)realloc ( pchChar , 10 ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Bad source pointer
void API_BadSourcePtr ( )
{
   _TRY
   {
      char szBuff[ 20 ] ;
      // This will also be a instrument compile error as well but it
      //  only will make a single popup error.
      strncpy ( szBuff , NULL , 10 ) ;
   }
   _CATCH
   {
   }
}

// API Check - Invalid argument: Conflicting combination of flags
void API_ConflictFlags_GetStringTypeEx ( )
{
   _TRY
   {
      TCHAR szSrc[] = _T ( "Test String" ) ;
      TCHAR szDest[ 12 ] ;

      GetStringTypeEx ( GetUserDefaultLCID ( ) ,
                        CT_CTYPE1 | CT_CTYPE2  ,
                        szSrc                  ,
                        -1                     ,
                        (LPWORD)szDest          ) ;
   }
   _CATCH
   {
   }
}
void API_ConflictFlags_VirtualFree ( )
{
   _TRY
   {
      LPVOID lpMem = VirtualAlloc ( NULL           ,
                                    0x100          ,
                                    MEM_COMMIT     ,
                                    PAGE_READWRITE  ) ;
      if ( NULL != lpMem )
      {
         VirtualFree ( lpMem ,
                       0     ,
                       MEM_DECOMMIT | MEM_RELEASE ) ;
         // With the invalid flags VirtualFree returns FALSE, so
         //  do the free so we don't leave resource leaks.
         VirtualFree ( lpMem ,
                       0     ,
                       MEM_RELEASE ) ;
      }
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Format string is not followed by
//             valid argument
void API_FmtStrNotFollowed ( )
{
   _TRY
   {

      char szDest[ 30 ] ;
      wvsprintf ( szDest , "%s" , NULL ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: General"
void API_General_HMENU ( )
{
   _TRY
   {
      DeleteMenu ( (HMENU)0xff00 ,
                   0             ,
                   MF_BYPOSITION  ) ;
   }
   _CATCH
   {
   }
}

void API_General_file ( )
{
   _TRY
   {
      fclose ( (FILE*)0x01 ) ;
   }
   _CATCH
   {
   }
}

void API_General_HDC ( )
{
   _TRY
   {
      COLORREF color = GetTextColor ( (HDC)0xabcd ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Invalid pointer to format string
void API_InvPtrToFmtString ( )
{
   _TRY
   {
      char szBuff [ 30 ] ;
      // This will also be a instrument compile error as well but it
      //  only will make a single popup error.
      wsprintf ( szBuff , NULL , "Happy string!" ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Not enough arguments for this
//             format string
void API_NotEnufArgsForFmtStr ( )
{
   _TRY
   {
      TCHAR szBuff [ 30 ] ;
      // This will also be an instrument compile error as well.
      wsprintf ( szBuff , _T ( "%d : %s" ) ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Out of range
void API_ArgOutOfRange_GetKeyState ( )
{
   _TRY
   {
      GetKeyState( 0XFFFF );
   }
   _CATCH
   {
   }
}
void API_ArgOutOfRange_CreateFont ( )
{
   _TRY
   {
      HFONT hFont = CreateFont ( 0                          ,
                                 0                          ,
                                 0                          ,
                                 0                          ,
                                 // Here is the value out of range.
                                 1000                       ,
                                 FALSE                      ,
                                 FALSE                      ,
                                 FALSE                      ,
                                 ANSI_CHARSET               ,
                                 OUT_CHARACTER_PRECIS       ,
                                 CLIP_DEFAULT_PRECIS        ,
                                 PROOF_QUALITY              ,
                                 VARIABLE_PITCH | FF_SWISS  ,
                                 _T ( "Arial" )              ) ;
      if ( NULL != hFont )
         DeleteObject ( (HGDIOBJ) hFont ) ;
   }
   _CATCH
   {
   }
}
void API_ArgOutOfRange_CreateFile ( )
{
   _TRY
   {
      HANDLE hFile = CreateFile ( _T ( "tmp.tmp" )             ,
                                  GENERIC_READ | GENERIC_WRITE ,
                                  0                            ,
                                  NULL                         ,
                                  // Here is the error!
                                  TRUNCATE_EXISTING + 1        ,
                                  FILE_ATTRIBUTE_NORMAL        ,
                                  NULL                          ) ;

      if ( INVALID_HANDLE_VALUE != hFile )
      {
         CloseHandle ( hFile ) ;
         DeleteFile ( _T ( "tmp.tmp" ) ) ;
      }
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Structure size field is not initialized
void API_StructSizeZero ( )
{
   _TRY
   {
      OSVERSIONINFO stOSVI ;
      memset ( &stOSVI , NULL , sizeof ( OSVERSIONINFO ) ) ;
      GetVersionEx ( &stOSVI ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid argument: Too many arguments for this
//             format string
void API_TooManyArgsForFmtStr ( )
{
   _TRY
   {
      TCHAR szBuff [ 30 ] ;
      UINT uiOne = 1 ;
      UINT uiTwo = 2 ;
      // This will also be an instrument compile error as well.
      wsprintf ( szBuff                   ,
                 _T ( "%s" )              ,
                 _T ( "Happy string!" )   ,
                 uiOne                    ,
                 uiTwo                     ) ;
   }
   _CATCH
   {
   }
}
// API Check - Invalid Argument : Undefined or illegal flags
void API_IllegalFlags_AppendMenu ( )
{
   _TRY
   {
      HMENU hMenu = CreateMenu ( ) ;
      AppendMenu ( hMenu                     ,
                   0x80000000L | MF_STRING   ,
                   0x100                     ,
                   _T ( "&New Item" )         ) ;
      DestroyMenu ( hMenu ) ;
   }
   _CATCH
   {
   }
}
void API_IllegalFlags_FoldString ( )
{
   _TRY
   {
      TCHAR szSource[] = _T ( "The source string 0-9" ) ;
      TCHAR szDest[ 50 ] ;

      FoldString ( 0x00000100 | MAP_FOLDDIGITS ,
                   szSource                    ,
                   -1                          ,
                   szDest                      ,
                   sizeof ( szDest )            ) ;
   }
   _CATCH
   {
   }
}
// API Check - Questionable use of thead
void ThreadFunc ( void * )
{
   void * pVoid = malloc ( 256 ) ;
   free ( pVoid ) ;
}
void API_QuestionableUseOfThread ( )
{
   DWORD dwID ;
   HANDLE hBadOne = CreateThread ( NULL   ,
                                   0      ,
                                   (LPTHREAD_START_ROUTINE)ThreadFunc ,
                                   0      ,
                                   0      ,
                                   &dwID   ) ;
   WaitForSingleObject ( hBadOne , 10000 ) ;
   CloseHandle ( hBadOne ) ;
}