FastMMMonitorTest.pas
上传用户:yjb1804
上传日期:2021-01-30
资源大小:3105k
文件大小:28k
源码类别:

Email服务器

开发平台:

Delphi

  1. { $Id: FastMMMonitorTest.pas,v 1.1 2006/07/19 02:53:13 judc Exp $ }
  2. {: DUnit: An XTreme testing framework for Delphi programs.
  3.    @author  The DUnit Group.
  4.    @version $Revision: 1.1 $
  5. }
  6. (*
  7.  * The contents of this file are subject to the Mozilla Public
  8.  * License Version 1.1 (the "License"); you may not use this file
  9.  * except in compliance with the License. You may obtain a copy of
  10.  * the License at http://www.mozilla.org/MPL/
  11.  *
  12.  * Software distributed under the License is distributed on an "AS
  13.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14.  * implied. See the License for the specific language governing
  15.  * rights and limitations under the License.
  16.  *
  17.  * The Original Code is DUnit.
  18.  *
  19.  * The Initial Developers of the Original Code are Kent Beck, Erich Gamma,
  20.  * and Juancarlo A馿z.
  21.  * Portions created The Initial Developers are Copyright (C) 1999-2000.
  22.  * Portions created by The DUnit Group are Copyright (C) 2000.
  23.  * All rights reserved.
  24.  *
  25.  * Contributor(s):
  26.  * Kent Beck <kentbeck@csi.com>
  27.  * Erich Gamma <Erich_Gamma@oti.com>
  28.  * Juanco A馿z <juanco@users.sourceforge.net>
  29.  * Chris Morris <chrismo@users.sourceforge.net>
  30.  * Jeff Moore <JeffMoore@users.sourceforge.net>
  31.  * Kris Golko <neuromancer@users.sourceforge.net>
  32.  * The DUnit group at SourceForge <http://dunit.sourceforge.net>
  33.  *
  34.  *)
  35. unit FastMMMonitorTest;
  36. interface
  37. uses
  38.   {$IFDEF FASTMM}
  39.     {$IFNDEF VER180}
  40.       FastMM4,
  41.     {$ENDIF}
  42.   {$ENDIF}
  43.   TestFramework,
  44.   SysUtils,
  45.   Contnrs;
  46. type
  47.   TBasicMemMonitor = class(TTestCase)
  48.   private
  49.     MLM : IDUnitMemLeakMonitor;
  50.     FLeakList: array[0..4] of integer; // As many as I think one might need
  51.     FLeakListIndex : Word;
  52.     function  Leaks: integer;
  53.     procedure SetLeakList(ListOfLeaks : array of integer);
  54.   public
  55.     procedure SetUp; override;
  56.     procedure TearDown; override;
  57.   published
  58.     procedure CheckMemManagerLoaded;
  59.     procedure CheckMemMonitorCreates;
  60.     procedure CheckMemMonitorDestroys;
  61.     procedure CheckMemMonitorComparesEqual;
  62.     procedure CheckMemMonitorRecoversMemOK;
  63.     procedure CheckMemMonitorFailsOnMemoryLeak;
  64.     procedure CheckMemMonitorPassOnMemRecovery;
  65.     procedure CheckMemMonitorFailsOnMemRecovery;
  66.     procedure CheckMemMonitorPassesOnAllowedMemRecovery;
  67.     procedure CheckMemMonitorPassedOnAllowedPositiveLeak;
  68.     procedure CheckMemMonitorPassOnListAllowedNoLeak0;
  69.     procedure CheckMemMonitorFailOnEmptyListAndPositiveLeak;
  70.     procedure CheckMemMonitorPassOnListAllowedPositiveLeak1;
  71.     procedure CheckMemMonitorFailOnEmptyListAndNegativeLeak;
  72.     procedure CheckMemMonitorPassOnListNegativeLeak;
  73.     procedure CheckMemMonitorPassOnListAllowedNegativeLeak1;
  74.     procedure CheckOffsetProperty;
  75.   end;
  76.   TMemMonitorGetErrorMessage = class(TTestCase)
  77.   private
  78.     MLM : IDUnitMemLeakMonitor;
  79.   public
  80.     procedure SetUp; override;
  81.     procedure TearDown; override;
  82.   published
  83.     procedure CheckGetMemoryUseMsgOK;
  84.     procedure CheckGetRecoveredMemMsg;
  85.     procedure CheckGetAllowedRecoveredMemMsg;
  86.     procedure CheckGetLeakedMemMsg;
  87.   end;
  88.   TMemMonitorGetErrorMessageNew = class(TTestCase)
  89.   private
  90.     MLM : IDUnitMemLeakMonitor;
  91.   public
  92.     procedure SetUp; override;
  93.     procedure TearDown; override;
  94.   published
  95.     procedure CheckSumOfLeaks;
  96.     procedure CheckGetMemoryUseMsgOK;
  97.     procedure CheckGetRecoveredMemMsg;
  98.     procedure CheckGetLeakedMemMsg;
  99.   end;
  100.   TMemMonitorStringLeakHandling = class(TTestCase)
  101.   private
  102.     fClearVarsInTearDown: boolean;
  103.   public
  104.     procedure SetUp; override;
  105.     procedure TearDown; override;
  106.   published
  107.     procedure CheckMemManagerNoLeaks1;
  108.     procedure CheckMemManagerNoLeaks2;
  109.     procedure CheckMemManagerLeaks;
  110.     procedure CheckMemManagerNoLeaks3;
  111.     procedure CheckMemManagerNoLeaks4;
  112.   end;
  113.   TMemMonitorObjectLeakHandling = class(TTestCase)
  114.   private
  115.     fClearVarsInTearDown: boolean;
  116.   public
  117.     procedure SetUp; override;
  118.     procedure TearDown; override;
  119.   published
  120.     procedure CheckMemManagerNoLeaks1;
  121.     procedure CheckMemManagerNoLeaks2;
  122.     procedure CheckMemManagerLeaks;
  123.     procedure CheckMemManagerNoLeaks3;
  124.     procedure CheckMemManagerNoLeaks4;
  125.   end;
  126.   TMemMonitorExceptLeakHandling = class(TTestCase)
  127.   private
  128.     fClearVarsInTearDown: boolean;
  129.   public
  130.     procedure SetUp; override;
  131.     procedure TearDown; override;
  132.   published
  133.     procedure CheckMemManagerNoLeaks1;
  134.     procedure CheckMemManagerNoLeaks2;
  135.     procedure CheckMemManagerLeaks;
  136.     procedure CheckMemManagerNoLeaks3;
  137.     procedure CheckMemManagerNoLeaks4;
  138.   end;
  139.   TMemMonitorMemAllocLeakHandling = class(TTestCase)
  140.   private
  141.     fClearVarsInTearDown: boolean;
  142.   public
  143.     procedure SetUp; override;
  144.     procedure TearDown; override;
  145.   published
  146.     procedure CheckMemManagerNoLeaks1;
  147.     procedure CheckMemManagerNoLeaks2;
  148.     procedure CheckMemManagerLeaks;
  149.     procedure CheckMemManagerNoLeaks3;
  150.     procedure CheckMemManagerNoLeaks4;
  151.   end;
  152. var
  153.   LeakedObject: TObject = nil;
  154.   Excpt: EAbort;
  155.   LeakyArray : array of Byte;
  156.   LeakyString : string;
  157.   LeakyMemory : PChar;
  158.   ObjectList : TObjectList;
  159.   procedure ClearVars;
  160.   function MemManagerLoaded: boolean;
  161. implementation
  162. uses
  163.   FastMMMemLeakMonitor;
  164. procedure ClearVars;
  165. begin
  166.   SetLength(LeakyArray,0);
  167.   LeakyArray := nil;
  168.   SetLength(LeakyString, 0);
  169.   LeakyString := '';
  170.   FreeAndNil(LeakedObject);
  171.   if (LeakyMemory <> nil) then
  172.   try
  173.     FreeMem(LeakyMemory);
  174.     LeakyMemory := nil;
  175.   except
  176.     LeakyMemory := nil;
  177.   end;
  178.   try
  179.     if Assigned(Excpt) then
  180.       raise excpt;
  181.   except
  182.     Excpt := nil;
  183.   end;
  184.   try
  185.     FreeAndNil(ObjectList);
  186.   except
  187.   end;
  188. end;
  189. procedure TBasicMemMonitor.SetUp;
  190. begin
  191.   inherited;
  192.   ClearVars;
  193.   MLM := nil;
  194. end;
  195. procedure TBasicMemMonitor.TearDown;
  196. begin
  197.   inherited;
  198.   try
  199.     ClearVars;
  200.   finally
  201.     MLM := nil;
  202.   end;
  203. end;
  204. function MemManagerLoaded: boolean;
  205. begin
  206.   {$IFDEF VER180}
  207.     Result := True;
  208.   {$ELSE}
  209.     Result := IsMemoryManagerSet;
  210.   {$ENDIF}
  211. end;
  212. procedure TBasicMemMonitor.CheckMemManagerLoaded;
  213. begin
  214.   Check(MemManagerLoaded, 'Memory Manager not loaded');
  215. end;
  216. procedure TBasicMemMonitor.CheckMemMonitorCreates;
  217. begin
  218.   try
  219.     MLM := TDUnitMemLeakMonitor.Create;
  220.   finally
  221.     Check(Assigned(MLM), 'MemLeakMonitor failed to create');
  222.     MLM := nil;
  223.   end;
  224. end;
  225. procedure TBasicMemMonitor.CheckMemMonitorDestroys;
  226. var
  227.   yyxx: boolean;
  228. begin
  229.   yyxx := False;
  230.   try
  231.     MLM := TDUnitMemLeakMonitor.Create;
  232.     yyxx := True;
  233.   finally
  234.     Check(Assigned(MLM), 'MemLeakMonitor failed to create');
  235.     try
  236.       Check(yyxx = True, 'MemLeakMonitor failed to create cleanly');
  237.       MLM := nil;
  238.       yyxx := False;
  239.     finally
  240.       Check(yyxx = False, 'MemLeakMonitor failed to Destroy cleanly');
  241.     end;
  242.   end;
  243. end;
  244. procedure TBasicMemMonitor.CheckMemMonitorComparesEqual;
  245. var
  246.   MemUsed    : Integer;
  247.   status     : boolean;
  248. begin
  249.   MLM := TDUnitMemLeakMonitor.Create;
  250.   status := (MLM as IMemLeakMonitor).MemLeakDetected(MemUsed);
  251.   Check(not status, 'Return result on equal memory comparison not set false');
  252.   Check((MemUsed=0), 'Return value on equal memory comparison does not equal zero');
  253. end;
  254. procedure TBasicMemMonitor.CheckMemMonitorRecoversMemOK;
  255. var
  256.   MemUsed : Integer;
  257.   status: boolean;
  258. begin
  259.   SetLength(LeakyArray, 100);
  260.   MLM := TDUnitMemLeakMonitor.Create;
  261.   SetLength(LeakyArray, 0);
  262.   LeakyArray := nil;
  263.   status := MLM.MemLeakDetected(0, False, MemUsed);
  264.   Check(not status, 'Return result on ignored less memory comparison not set False');
  265.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  266. end;
  267. procedure TBasicMemMonitor.CheckMemMonitorPassOnMemRecovery;
  268. var
  269.   MemUsed : Integer;
  270.   status: boolean;
  271. begin
  272.   SetLength(LeakyArray, 100);
  273.   MLM := TDUnitMemLeakMonitor.Create;
  274.   SetLength(LeakyArray, 0);
  275.   LeakyArray := nil;
  276.   status := MLM.MemLeakDetected(0, False, MemUsed);
  277.   Check(not status, 'Return result on memory recovery set True');
  278.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  279. end;
  280. procedure TBasicMemMonitor.CheckMemMonitorFailsOnMemRecovery;
  281. var
  282.   MemUsed : Integer;
  283.   status: boolean;
  284. begin
  285.   SetLength(LeakyArray, 100);
  286.   MLM := TDUnitMemLeakMonitor.Create;
  287.   SetLength(LeakyArray, 0);
  288.   LeakyArray := nil;
  289.   status := MLM.MemLeakDetected(0, True, MemUsed);
  290.   Check(status, 'Return result on memory recovery set False');
  291.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  292. end;
  293. procedure TBasicMemMonitor.CheckMemMonitorPassesOnAllowedMemRecovery;
  294. var
  295.   MemUsed : Integer;
  296.   status: boolean;
  297. begin
  298.   SetLength(LeakyArray, 100);
  299.   MLM := TDUnitMemLeakMonitor.Create;
  300.   SetLength(LeakyArray, 0);
  301.   LeakyArray := nil;
  302.   status := MLM.MemLeakDetected(-112, True, MemUsed);
  303.   Check(not status, 'Return result on less memory comparison set False');
  304.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  305. end;
  306. procedure TBasicMemMonitor.CheckMemMonitorFailsOnMemoryLeak;
  307. var
  308.   MemUsed : Integer;
  309.   status: boolean;
  310. begin
  311.   MLM := TDUnitMemLeakMonitor.Create;
  312.   SetLength(LeakyArray, 100);
  313.   try
  314.     status := (MLM as IMemLeakMonitor).MemLeakDetected(MemUsed);
  315.     Check(status, 'Return result on less memory comparison not set true');
  316.     Check((MemUsed > 0), 'Return value leaked memory comparison not greater than zero');
  317.   finally
  318.     SetLength(LeakyArray, 0);
  319.     LeakyArray := nil;
  320.   end;
  321. end;
  322. procedure TBasicMemMonitor.CheckMemMonitorPassedOnAllowedPositiveLeak;
  323. var
  324.   MemUsed : Integer;
  325.   status: boolean;
  326. begin
  327.   MLM := TDUnitMemLeakMonitor.Create;
  328.   SetLength(LeakyArray, 100);
  329.   try
  330.     status := MLM.MemLeakDetected(112, True, MemUsed);
  331.     Check(not status, 'Return result on offset memory comparison not set true');
  332.     Check((MemUsed = 112), 'Return value = ' + IntToStr(MemUsed) +
  333.       ' Should be 112');
  334.   finally
  335.     SetLength(LeakyArray, 0);
  336.     LeakyArray := nil;
  337.   end;
  338. end;
  339. procedure TBasicMemMonitor.CheckMemMonitorFailOnEmptyListAndPositiveLeak;
  340. var
  341.   MemUsed : Integer;
  342.   status: boolean;
  343. begin
  344.   MLM := TDUnitMemLeakMonitor.Create;
  345.   SetLength(LeakyArray, 100);
  346.   try
  347.     status := MLM.MemLeakDetected(leaks, True, MemUsed);
  348.     Check(status, 'Return result on empty array with leak was set False');
  349.     Check((MemUsed = 112), 'Return value = ' + IntToStr(MemUsed) +
  350.       ' Should be 112');
  351.   finally
  352.     SetLength(LeakyArray, 0);
  353.     LeakyArray := nil;
  354.   end;
  355. end;
  356. procedure TBasicMemMonitor.CheckMemMonitorPassOnListAllowedNoLeak0;
  357. var
  358.   MemUsed : Integer;
  359.   status: boolean;
  360. begin
  361.   MLM := TDUnitMemLeakMonitor.Create;
  362.   SetLength(LeakyArray, 100);
  363.   try
  364.     status := MLM.MemLeakDetected(112, True, MemUsed);
  365.     Check(not status, 'Return result on offset memory comparison not set true');
  366.     Check((MemUsed = 112), 'Return value = ' + IntToStr(MemUsed) +
  367.       ' Should be 112');
  368.   finally
  369.     SetLength(LeakyArray, 0);
  370.     LeakyArray := nil;
  371.   end;
  372. end;
  373. procedure TBasicMemMonitor.CheckMemMonitorPassOnListAllowedPositiveLeak1;
  374. var
  375.   MemUsed : Integer;
  376.   status: boolean;
  377.   LIndex: integer;
  378. begin
  379.   SetLeakList([112]);
  380.   MLM := TDUnitMemLeakMonitor.Create;
  381.   SetLength(LeakyArray, 100);
  382.   try
  383.     status := MLM.MemLeakDetected(leaks, True, MemUsed);
  384.     Check(not status, 'Return result on single matching allowed not set true');
  385.     SetLeakList([112,1]);
  386.     status := MLM.MemLeakDetected(Leaks, True, LIndex, MemUsed);
  387.     Check(not status, 'Return result on 1st in list match not set true');
  388.     SetLeakList([1, 112]);
  389.     status := MLM.MemLeakDetected(Leaks, True, LIndex, MemUsed);
  390.     Check(not status, 'Return result on 2nd in list not set true');
  391.     Check((MemUsed = 112), 'Return value = ' + IntToStr(MemUsed) +
  392.       ' Should be 112');
  393.   finally
  394.     SetLength(LeakyArray, 0);
  395.     LeakyArray := nil;
  396.   end;
  397. end;
  398. procedure TBasicMemMonitor.CheckMemMonitorFailOnEmptyListAndNegativeLeak;
  399. var
  400.   MemUsed : Integer;
  401.   status: boolean;
  402. begin
  403.   SetLength(LeakyArray, 100);
  404.   MLM := TDUnitMemLeakMonitor.Create;
  405.   SetLength(LeakyArray, 0);
  406.   LeakyArray := nil;
  407.   SetLeakList([0]);
  408.   status := MLM.MemLeakDetected(Leaks, True, MemUsed);
  409.   Check(status, 'Return result on less memory comparison set False');
  410.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  411. end;
  412. procedure TBasicMemMonitor.CheckMemMonitorPassOnListNegativeLeak;
  413. var
  414.   MemUsed : Integer;
  415.   status: boolean;
  416.   LIndex: integer;
  417. begin
  418.   SetLength(LeakyArray, 100);
  419.   MLM := TDUnitMemLeakMonitor.Create;
  420.   SetLength(LeakyArray, 0);
  421.   LeakyArray := nil;
  422.   SetLeakList([]);
  423.   status := MLM.MemLeakDetected(Leaks, False, MemUsed);
  424.   Check(not status, 'Return result on memory recovery set true');
  425.   status := MLM.MemLeakDetected(Leaks, False, LIndex, MemUsed);
  426.   Check(not status, 'Return result on empty list memory recovery set true');
  427.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  428. end;
  429. procedure TBasicMemMonitor.CheckMemMonitorPassOnListAllowedNegativeLeak1;
  430. var
  431.   MemUsed : Integer;
  432.   status: boolean;
  433.   LIndex: integer;
  434. begin
  435.   SetLength(LeakyArray, 100);
  436.   MLM := TDUnitMemLeakMonitor.Create;
  437.   SetLength(LeakyArray, 0);
  438.   LeakyArray := nil;
  439.   SetLeakList([-112]);
  440.   status := MLM.MemLeakDetected(Leaks, True, MemUsed);
  441.   Check(not status, 'Return result on single matching allowed not set true');
  442.   SetLeakList([-112, 1]);
  443.   status := MLM.MemLeakDetected(Leaks, True, LIndex, MemUsed);
  444.   Check(not status, 'Return result on 1st in list match not set true');
  445.   SetLeakList([1, -112]);
  446.   status := MLM.MemLeakDetected(Leaks, True, LIndex, MemUsed);
  447.   Check(not status, 'Return result on 2nd in list not set true');
  448.   Check((MemUsed < 0), 'Return value on freed up memory comparison not less than zero');
  449. end;
  450. procedure TBasicMemMonitor.CheckOffsetProperty;
  451. begin
  452.   Check(AllowedMemoryLeakSize = 0,
  453.     ' AllowedMemoryLeakSize should always be zero on entry but was '
  454.     + IntToStr(AllowedMemoryLeakSize));
  455.   AllowedMemoryLeakSize := 10;
  456.   Check(AllowedMemoryLeakSize = 10,
  457.     ' AllowedMemoryLeakSize should always be 10 but was '
  458.     + IntToStr(AllowedMemoryLeakSize));
  459.   AllowedMemoryLeakSize := AllowedMemoryLeakSize - 10;
  460.   Check(AllowedMemoryLeakSize = 0,
  461.     ' AllowedMemoryLeakSize should always be 0 but was '
  462.     + IntToStr(AllowedMemoryLeakSize));
  463. end;
  464. {------------------------------------------------------------------------------}
  465. { TMemMonitorStringLeakHandling }
  466. procedure TMemMonitorStringLeakHandling.SetUp;
  467. begin
  468.   inherited;
  469.   ClearVars;
  470.   fClearVarsInTearDown := True;
  471. end;
  472. procedure TMemMonitorStringLeakHandling.TearDown;
  473. begin
  474.   inherited;
  475.   if fClearVarsInTearDown then
  476.     ClearVars;
  477. end;
  478. procedure TMemMonitorStringLeakHandling.CheckMemManagerLeaks;
  479. begin
  480.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  481.   SetLength(LeakyString,200);
  482.   fClearVarsInTearDown := False;
  483. end;
  484. procedure TMemMonitorStringLeakHandling.CheckMemManagerNoLeaks1;
  485. begin
  486.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  487.   SetLength(LeakyString,200);
  488.   fClearVarsInTearDown := True;
  489. end;
  490. procedure TMemMonitorStringLeakHandling.CheckMemManagerNoLeaks2;
  491. begin
  492.   CheckMemManagerNoLeaks1;
  493. end;
  494. procedure TMemMonitorStringLeakHandling.CheckMemManagerNoLeaks3;
  495. begin
  496.   CheckMemManagerNoLeaks1;
  497. end;
  498. procedure TMemMonitorStringLeakHandling.CheckMemManagerNoLeaks4;
  499. begin
  500.   CheckMemManagerNoLeaks1;
  501. end;
  502. { TMemMonitorObjectLeakHandling }
  503. procedure TMemMonitorObjectLeakHandling.SetUp;
  504. begin
  505.   inherited;
  506.   ClearVars;
  507.   fClearVarsInTearDown := True;
  508. end;
  509. procedure TMemMonitorObjectLeakHandling.TearDown;
  510. begin
  511.   inherited;
  512.   if fClearVarsInTearDown then
  513.     ClearVars;
  514. end;
  515. procedure TMemMonitorObjectLeakHandling.CheckMemManagerLeaks;
  516. begin
  517.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  518.   LeakedObject := TObject.Create;
  519.   fClearVarsInTearDown := False;
  520. end;
  521. procedure TMemMonitorObjectLeakHandling.CheckMemManagerNoLeaks1;
  522. begin
  523.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  524.   LeakedObject := TObject.Create;
  525.   fClearVarsInTearDown := True;
  526. end;
  527. procedure TMemMonitorObjectLeakHandling.CheckMemManagerNoLeaks2;
  528. begin
  529.   CheckMemManagerNoLeaks1;
  530. end;
  531. procedure TMemMonitorObjectLeakHandling.CheckMemManagerNoLeaks3;
  532. begin
  533.   CheckMemManagerNoLeaks1;
  534. end;
  535. procedure TMemMonitorObjectLeakHandling.CheckMemManagerNoLeaks4;
  536. begin
  537.   CheckMemManagerNoLeaks1;
  538. end;
  539. { TMemMonitorExceptLeakHandling }
  540. procedure TMemMonitorExceptLeakHandling.SetUp;
  541. begin
  542.   inherited;
  543.   ClearVars;
  544.   fClearVarsInTearDown := True;
  545. end;
  546. procedure TMemMonitorExceptLeakHandling.TearDown;
  547. begin
  548.   inherited;
  549.   if fClearVarsInTearDown then
  550.     ClearVars;
  551. end;
  552. procedure TMemMonitorExceptLeakHandling.CheckMemManagerLeaks;
  553. begin
  554.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  555.   Excpt := EAbort.Create('');
  556.   fClearVarsInTearDown := False;
  557. end;
  558. procedure TMemMonitorExceptLeakHandling.CheckMemManagerNoLeaks1;
  559. begin
  560.   Check(IsMemoryManagerSet, 'Memory Manager not loaded');
  561.   Excpt := EAbort.Create('');
  562.   fClearVarsInTearDown := True;
  563. end;
  564. procedure TMemMonitorExceptLeakHandling.CheckMemManagerNoLeaks2;
  565. begin
  566.   CheckMemManagerNoLeaks1;
  567. end;
  568. procedure TMemMonitorExceptLeakHandling.CheckMemManagerNoLeaks3;
  569. begin
  570.   CheckMemManagerNoLeaks1;
  571. end;
  572. procedure TMemMonitorExceptLeakHandling.CheckMemManagerNoLeaks4;
  573. begin
  574.   CheckMemManagerNoLeaks1;
  575. end;
  576. { TMemMonitorMemAllocLeakHandling }
  577. procedure TMemMonitorMemAllocLeakHandling.CheckMemManagerLeaks;
  578. begin
  579.   Check(MemManagerLoaded, 'Memory Manager not loaded');
  580.   GetMem(LeakyMemory, 1000);
  581.   fClearVarsInTearDown := False;
  582. end;
  583. procedure TMemMonitorMemAllocLeakHandling.CheckMemManagerNoLeaks1;
  584. begin
  585.   Check(MemManagerLoaded, 'Memory Manager not loaded');
  586.   GetMem(LeakyMemory, 1000);
  587.   fClearVarsInTearDown := True;
  588. end;
  589. procedure TMemMonitorMemAllocLeakHandling.CheckMemManagerNoLeaks2;
  590. begin
  591.   CheckMemManagerNoLeaks1;
  592. end;
  593. procedure TMemMonitorMemAllocLeakHandling.CheckMemManagerNoLeaks3;
  594. begin
  595.   CheckMemManagerNoLeaks1;
  596. end;
  597. procedure TMemMonitorMemAllocLeakHandling.CheckMemManagerNoLeaks4;
  598. begin
  599.   CheckMemManagerNoLeaks1;
  600. end;
  601. procedure TMemMonitorMemAllocLeakHandling.SetUp;
  602. begin
  603.   inherited;
  604.   ClearVars;
  605.   fClearVarsInTearDown := True;
  606. end;
  607. procedure TMemMonitorMemAllocLeakHandling.TearDown;
  608. begin
  609.   inherited;
  610.   if fClearVarsInTearDown then
  611.     ClearVars;
  612. end;
  613. { TMemMonitorGetErrorMessage }
  614. procedure TMemMonitorGetErrorMessage.SetUp;
  615. begin
  616.   inherited;
  617.   ClearVars;
  618.   MLM := nil;
  619. end;
  620. procedure TMemMonitorGetErrorMessage.TearDown;
  621. begin
  622.   inherited;
  623.   try
  624.     ClearVars;
  625.   finally
  626.     MLM := nil;
  627.   end;
  628. end;
  629. procedure TMemMonitorGetErrorMessage.CheckGetMemoryUseMsgOK;
  630. var
  631.   ErrorStr: string;
  632.   Status: boolean;
  633. begin
  634.   MLM := TDUnitMemLeakMonitor.Create;
  635.   status := MLM.GetMemoryUseMsg(False, 0, ErrorStr);
  636.   Check(Status, 'Status should be True');
  637.   Check(ErrorStr = '', 'Simple Test String should be empty but = ' + ErrorStr);
  638.   status := MLM.GetMemoryUseMsg(True, 0, ErrorStr);
  639.   Check(Status, 'Status should be True');
  640.   Check(ErrorStr = '', 'Simple Test String should be empty but = ' + ErrorStr);
  641. end;
  642. procedure TMemMonitorGetErrorMessage.CheckGetRecoveredMemMsg;
  643. var
  644.   ErrorStr: string;
  645.   Status: boolean;
  646. begin
  647.   MLM := TDUnitMemLeakMonitor.Create;
  648.   status := MLM.GetMemoryUseMsg(False, -1, ErrorStr);
  649.   Check(Status, 'Status should be True');
  650.   Check(ErrorStr = '', 'Simple Test string should be empty');
  651. end;
  652. procedure TMemMonitorGetErrorMessage.CheckGetAllowedRecoveredMemMsg;
  653. var
  654.   ErrorStr: string;
  655.   Status: boolean;
  656. begin
  657.   MLM := TDUnitMemLeakMonitor.Create;
  658.   status := MLM.GetMemoryUseMsg(True, -1, ErrorStr);
  659.   Check(not Status, 'Status should be False');
  660.   Check(ErrorStr <> '', 'Simple Test string should not be empty');
  661.   Check(ErrorStr = '1 Bytes Memory Recovered in Test Procedure',
  662.    ' Error String reads <' + ErrorStr +
  663.    '> but should read  <1 Bytes Memory Recovered in Test Procedure>');
  664. end;
  665. procedure TMemMonitorGetErrorMessage.CheckGetLeakedMemMsg;
  666. var
  667.   ErrorStr: string;
  668.   Status: boolean;
  669. begin
  670.   MLM := TDUnitMemLeakMonitor.Create;
  671.   status := MLM.GetMemoryUseMsg(False, 1, ErrorStr);
  672.   Check(not Status, 'Status should be False');
  673.   Check(ErrorStr = '1 Bytes Memory Leak in Test Procedure',
  674.    ' Error String reads <' + ErrorStr +
  675.    '> but should read  <1 Bytes Memory Leak in Test Procedure>');
  676.   status := MLM.GetMemoryUseMsg(True, 1, ErrorStr);
  677.   Check(not Status, 'Status should be False');
  678.   Check(ErrorStr = '1 Bytes Memory Leak in Test Procedure',
  679.    ' Error String reads <' + ErrorStr +
  680.    '> but should read  <1 Bytes Memory Leak in Test Procedure>');
  681. end;
  682. function TBasicMemMonitor.Leaks: integer;
  683. begin
  684.   if FLeakListIndex >= Length(FLeakList) then
  685.     result := 0
  686.   else
  687.   begin
  688.     result := FLeakList[FLeakListIndex];
  689.     inc(FLeakListIndex);
  690.   end;
  691. end;
  692. procedure TBasicMemMonitor.SetLeakList(ListOfLeaks: array of integer);
  693. var
  694.   I: Integer;
  695. begin
  696.   for I := 0 to Length(FLeakList) - 1 do    // Iterate
  697.   begin
  698.     if I < Length(ListOfLeaks) then
  699.       FLeakList[I] := ListOfLeaks[I]
  700.     else
  701.       FLeakList[I] := 0;
  702.   end;    // for
  703.   FLeakListIndex := 0;
  704. end;
  705. { TMemMonitorGetErrorMessageNew }
  706. procedure TMemMonitorGetErrorMessageNew.SetUp;
  707. begin
  708.   inherited;
  709.   ClearVars;
  710.   MLM := nil;
  711. end;
  712. procedure TMemMonitorGetErrorMessageNew.TearDown;
  713. begin
  714.   inherited;
  715.   try
  716.     ClearVars;
  717.   finally
  718.     MLM := nil;
  719.   end;
  720. end;
  721. procedure TMemMonitorGetErrorMessageNew.CheckSumOfLeaks;
  722. var
  723.   ErrorStr: string;
  724.   Status: boolean;
  725. begin
  726.   MLM := TDUnitMemLeakMonitor.Create;
  727.   status := MLM.GetMemoryUseMsg(False, 0, 0, 0, 1, ErrorStr);
  728.   Check(not Status, 'Status should be False');
  729.   Check(ErrorStr =
  730.     ('Error in TestFrameWork. No leaks in Setup, TestProc or Teardown but '+
  731.     '1 Bytes Memory Leak reported across TestCase'), 'ErrorStr = ' + ErrorStr);
  732.   status := MLM.GetMemoryUseMsg(False, 1, 2, 3, 1, ErrorStr);
  733.   Check(not Status, 'Status should be False');
  734.   Check(ErrorStr =
  735.     ('Error in TestFrameWork. Sum of Setup, TestProc and Teardown leaks <> '+
  736.     '1 Bytes Memory Leak reported across TestCase'), 'ErrorStr = ' + ErrorStr);
  737. end;
  738. procedure TMemMonitorGetErrorMessageNew.CheckGetMemoryUseMsgOK;
  739. var
  740.   ErrorStr: string;
  741.   Status: boolean;
  742. begin
  743.   MLM := TDUnitMemLeakMonitor.Create;
  744.   status := MLM.GetMemoryUseMsg(False, 0, 0, 0, 0, ErrorStr);
  745.   Check(Status, 'Status should be True');
  746.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  747.   status := MLM.GetMemoryUseMsg(True, 0, 0, 0, 0, ErrorStr);
  748.   Check(Status, 'Status should be True');
  749.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  750. end;
  751. procedure TMemMonitorGetErrorMessageNew.CheckGetRecoveredMemMsg;
  752. var
  753.   ErrorStr: string;
  754.   Status: boolean;
  755. begin
  756.   MLM := TDUnitMemLeakMonitor.Create;
  757.   status := MLM.GetMemoryUseMsg(False, -1, 0, 0, -1, ErrorStr);
  758.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  759.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  760.   status := MLM.GetMemoryUseMsg(False,  0, -1, 0, -1, ErrorStr);
  761.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  762.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  763.   status := MLM.GetMemoryUseMsg(False,  0, 0, -1, -1, ErrorStr);
  764.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  765.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  766.   status := MLM.GetMemoryUseMsg(False, -1, -2, 0, -3, ErrorStr);
  767.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  768.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  769.   status := MLM.GetMemoryUseMsg(False,  0, -1, -2, -3, ErrorStr);
  770.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  771.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  772.   status := MLM.GetMemoryUseMsg(False,  -1, -2, -3, -6, ErrorStr);
  773.   Check(Status, 'Status should be True. ErrorMessage =' + ErrorStr);
  774.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  775.   status := MLM.GetMemoryUseMsg(True, -1, 0, 0, -1, ErrorStr);
  776.   Check(not Status, 'Status should be False');
  777.   Check(ErrorStr = '-1 Bytes memory recovered  (Setup= -1  )',
  778.     'ErrorMsg should read <-1 Bytes memory recovered  (Setup= -1  )>'+
  779.     ' but was <' + ErrorStr + '>');
  780.   status := MLM.GetMemoryUseMsg(True, 0, -1, 0, -1, ErrorStr);
  781.   Check(not Status, 'Status should be False');
  782.   Check(ErrorStr = '-1 Bytes memory recovered  (' +
  783.     'TestProc= -1  )',
  784.     'ErrorMsg should read <-1 Bytes memory recovered   (TestProc= -1  )>' +
  785.     ' but was <' + ErrorStr + '>');
  786.   status := MLM.GetMemoryUseMsg(True, 0, 0, -1, -1, ErrorStr);
  787.   Check(not Status, 'Status should be False');
  788.   Check(ErrorStr = '-1 Bytes memory recovered  (' +
  789.     'TearDown= -1  )',
  790.     'ErrorMsg should read <-1 Bytes memory recovered  (TearDown= -1  )>'+
  791.     ' but was <' + ErrorStr + '>');
  792.   status := MLM.GetMemoryUseMsg(True, -1, -2, -3, -6, ErrorStr);
  793.   Check(not Status, 'Status should be False');
  794.   Check(ErrorStr = '-6 Bytes memory recovered  (' +
  795.     'Setup= -1  TestProc= -2  TearDown= -3  )',
  796.     'ErrorMsg should read ' +
  797.     '<-6 Bytes memory recovered  (Setup= -1  TestProc= -2  TearDown= -3  )>' +
  798.     ' but was <' + ErrorStr + '>');
  799. end;
  800. procedure TMemMonitorGetErrorMessageNew.CheckGetLeakedMemMsg;
  801. var
  802.   ErrorStr: string;
  803.   Status: boolean;
  804. begin
  805.   MLM := TDUnitMemLeakMonitor.Create;
  806.   status := MLM.GetMemoryUseMsg(False, 0, 0, 0, 0, ErrorStr);
  807.   Check(Status, 'Status should be True');
  808.   Check(ErrorStr = '', 'Complete Test String should be empty but = ' + ErrorStr);
  809.   status := MLM.GetMemoryUseMsg(False, 1, 0, 0, 1, ErrorStr);
  810.   Check(not Status, 'Status should be False');
  811.   Check(ErrorStr = '1 Bytes memory leak  (' +
  812.     'Setup= 1  )',
  813.     'ErrorMsg should read <1 Bytes memory leak  (Setup= 1  )' +
  814.     ' but was <' + ErrorStr + '>');
  815.   status := MLM.GetMemoryUseMsg(False, 1, 0, 0, 1, ErrorStr);
  816.   Check(not Status, 'Status should be False');
  817.   Check(ErrorStr = '1 Bytes memory leak  (' +
  818.     'Setup= 1  )',
  819.     'ErrorMsg should read <1 Bytes memory leak  (Setup=1  )' +
  820.     ' but was <' + ErrorStr + '>');
  821.   status := MLM.GetMemoryUseMsg(False, 0, 1, 0, 1, ErrorStr);
  822.   Check(not Status, 'Status should be False');
  823.   Check(ErrorStr = '1 Bytes memory leak  (' +
  824.     'TestProc= 1  )',
  825.     'ErrorMsg should read <1 Bytes memory leak  (TestProc= 1  )>' +
  826.     ' but was <' + ErrorStr + '>');
  827.   status := MLM.GetMemoryUseMsg(False, 0, 0, 1, 1, ErrorStr);
  828.   Check(not Status, 'Status should be False');
  829.   Check(ErrorStr = '1 Bytes memory leak  (' +
  830.     'TearDown= 1  )',
  831.     'ErrorMsg should read <1 Bytes memory leak  (TearDown= 1  )>' +
  832.     ' but was <' + ErrorStr + '>');
  833.   status := MLM.GetMemoryUseMsg(False, 1, 2, 0, 3, ErrorStr);
  834.   Check(not Status, 'Status should be False');
  835.   Check(ErrorStr = '3 Bytes memory leak  (' +
  836.     'Setup= 1  TestProc= 2  )',
  837.     'ErrorMsg should read <3 Bytes memory leak  (Setup= 1  TestProc= 2  )>' +
  838.     ' but was <' + ErrorStr + '>');
  839.   status := MLM.GetMemoryUseMsg(False, 0, 2, 1, 3, ErrorStr);
  840.   Check(not Status, 'Status should be False');
  841.   Check(ErrorStr = '3 Bytes memory leak  (' +
  842.     'TestProc= 2  TearDown= 1  )',
  843.     'ErrorMsg should read <3 Bytes memory leak  (TestProc= 2  TearDown= 1  )>' +
  844.     ' but was <' + ErrorStr + '>');
  845.   status := MLM.GetMemoryUseMsg(False, 1, 0, 2, 3, ErrorStr);
  846.   Check(not Status, 'Status should be False');
  847.   Check(ErrorStr = '3 Bytes memory leak  (' +
  848.     'Setup= 1  TearDown= 2  )',
  849.     'ErrorMsg should read <3 Bytes memory leak  (Setup= 1  TearDown= 2  )>' +
  850.     ' but was <' + ErrorStr + '>');
  851.   status := MLM.GetMemoryUseMsg(False, 1, 2, 3, 6, ErrorStr);
  852.   Check(not Status, 'Status should be False');
  853.   Check(ErrorStr = '6 Bytes memory leak  (' +
  854.     'Setup= 1  TestProc= 2  TearDown= 3  )',
  855.     'ErrorMsg should read ' +
  856.     '<3 Bytes memory leak  (Setup= 1  TestProc= 2  TearDown= 3  )>' +
  857.     ' but was <' + ErrorStr + '>');
  858. end;
  859. initialization
  860.   Excpt := nil;
  861.   LeakyMemory := nil;
  862.   LeakyString := '';
  863.   ObjectList := nil;
  864. end.