tools/leaky/TestLeaky.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is mozilla.org code.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Kipp E.B. Hickman.
  18  * Portions created by the Initial Developer are Copyright (C) 1999
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #include <stdio.h>
  38 #include <malloc.h>
  39
  40 void s1(int, int)
  41 {
  42     malloc(100);
  43 }
  44
  45 void s2()
  46 {
  47     s1(1, 2);
  48     malloc(100);
  49 }
  50
  51 void s3()
  52 {
  53     s2();
  54     malloc(100);
  55     malloc(200);
  56 }
  57
  58 void s4()
  59 {
  60     s3();
  61     char* cp = new char[300];
  62     cp = cp;
  63 }
  64
  65 // Test that mutually recrusive methods don't foul up the graph output
  66 void s6(int recurse);
  67
  68 void s5(int recurse)
  69 {
  70     malloc(100);
  71     if (recurse > 0) {
  72       s6(recurse - 1);
  73     }
  74 }
  75
  76 void s6(int recurse)
  77 {
  78     malloc(100);
  79     if (recurse > 0) {
  80       s5(recurse - 1);
  81     }
  82 }
  83
  84 // Test that two pathways through the same node don't cause replicated
  85 // descdendants (A -> B -> C, X -> B -> D shouldn't produce a graph
  86 // that shows A -> B -> D!)
  87
  88 void C()
  89 {
  90   malloc(10);
  91 }
  92
  93 void D()
  94 {
  95   malloc(10);
  96 }
  97
  98 void B(int way)
  99 {
 100   malloc(10);
 101   if (way) {
 102     C();
 103     C();
 104     C();
 105   } else {
 106     D();
 107   }
 108 }
 109
 110 void A()
 111 {
 112   malloc(10);
 113   B(1);
 114 }
 115
 116 void X()
 117 {
 118   malloc(10);
 119   B(0);
 120 }
 121
 122 int main()
 123 {
 124   s1(1, 2);
 125   s2();
 126   s3();
 127   s4();
 128   s5(10);
 129   A();
 130   X();
 131 }