test-suite/syntheticoperators.cc

   1
   2 /*
   3  * $Id$
   4  *
   5  * AUTHOR: Robert Collins
   6  *
   7  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   8  * ----------------------------------------------------------
   9  *
  10  *  Squid is the result of efforts by numerous individuals from
  11  *  the Internet community; see the CONTRIBUTORS file for full
  12  *  details.   Many organizations have provided support for Squid's
  13  *  development; see the SPONSORS file for full details.  Squid is
  14  *  Copyrighted (C) 2001 by the Regents of the University of
  15  *  California; see the COPYRIGHT file for full details.  Squid
  16  *  incorporates software developed and/or copyrighted by other
  17  *  sources; see the CREDITS file for full details.
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation; either version 2 of the License, or
  22  *  (at your option) any later version.
  23  *
  24  *  This program is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32  *
  33  * Copyright (c) 2003  Robert Collins <robertc@squid-cache.org>
  34  */
  35
  36 #include "squid-old.h"
  37 #include "stmem.h"
  38 #include "mem_node.h"
  39
  40 #if HAVE_IOSTREAM
  41 #include <iostream>
  42 #endif
  43
  44 class HasExplicit
  45 {
  46 public:
  47     HasExplicit();
  48     ~HasExplicit();
  49     HasExplicit(HasExplicit const &);
  50     HasExplicit &operator=(HasExplicit const &);
  51     static int const &Instances();
  52     static int const &Assignments();
  53     static void Assignments(int const &);
  54 private:
  55     static void AddInstance();
  56     static void RemoveInstance();
  57     static void Assignment();
  58     static int Instances_;
  59     static int Assignments_;
  60 };
  61
  62 int HasExplicit::Instances_(0);
  63 int HasExplicit::Assignments_(0);
  64
  65 HasExplicit::HasExplicit()
  66 {
  67     AddInstance();
  68 }
  69
  70 HasExplicit::~HasExplicit()
  71 {
  72     RemoveInstance();
  73 }
  74
  75 HasExplicit::HasExplicit(HasExplicit const &)
  76 {
  77     AddInstance();
  78 }
  79
  80 HasExplicit &
  81 HasExplicit::operator= (HasExplicit const &)
  82 {
  83     Assignment();
  84     return *this;
  85 }
  86
  87 void
  88 HasExplicit::AddInstance()
  89 {
  90     ++Instances_;
  91 }
  92
  93 void
  94 HasExplicit::RemoveInstance()
  95 {
  96     --Instances_;
  97 }
  98
  99 void
 100 HasExplicit::Assignment()
 101 {
 102     ++Assignments_;
 103 }
 104
 105 int const &
 106 HasExplicit::Instances()
 107 {
 108     return Instances_;
 109 }
 110
 111 int const &
 112 HasExplicit::Assignments()
 113 {
 114     return Assignments_;
 115 }
 116
 117 void
 118 HasExplicit::Assignments(int const &newValue)
 119 {
 120     Assignments_ = newValue;
 121 }
 122
 123 void
 124 CheckHasExplicitWorks()
 125 {
 126     assert (HasExplicit::Instances() == 0);
 127     HasExplicit *one = new HasExplicit;
 128     assert (HasExplicit::Instances() == 1);
 129     HasExplicit *two = new HasExplicit;
 130     assert (HasExplicit::Instances() == 2);
 131     *two = *one;
 132     assert (HasExplicit::Instances() == 2);
 133     assert (HasExplicit::Assignments() == 1);
 134     *two = *one;
 135     assert (HasExplicit::Instances() == 2);
 136     assert (HasExplicit::Assignments() == 2);
 137     HasExplicit *three = new HasExplicit(*two);
 138     assert (HasExplicit::Instances() == 3);
 139     delete three;
 140     assert (HasExplicit::Instances() == 2);
 141     delete one;
 142     assert (HasExplicit::Instances() == 1);
 143     delete two;
 144     assert (HasExplicit::Instances() == 0);
 145     HasExplicit::Assignments(0);
 146     assert (HasExplicit::Assignments() == 0);
 147 }
 148
 149 class SyntheticOwnsExplicit
 150 {
 151 public:
 152     HasExplicit aMember;
 153 };
 154
 155 void
 156 CheckSyntheticWorks()
 157 {
 158     assert (HasExplicit::Instances() == 0);
 159     assert (HasExplicit::Assignments() == 0);
 160     SyntheticOwnsExplicit *one = new SyntheticOwnsExplicit;
 161     assert (HasExplicit::Instances() == 1);
 162     SyntheticOwnsExplicit *two = new SyntheticOwnsExplicit;
 163     assert (HasExplicit::Instances() == 2);
 164     *two = *one;
 165     assert (HasExplicit::Instances() == 2);
 166     assert (HasExplicit::Assignments() == 1);
 167     *two = *one;
 168     assert (HasExplicit::Instances() == 2);
 169     assert (HasExplicit::Assignments() == 2);
 170     SyntheticOwnsExplicit *three = new SyntheticOwnsExplicit(*two);
 171     assert (HasExplicit::Instances() == 3);
 172     delete three;
 173     assert (HasExplicit::Instances() == 2);
 174     delete one;
 175     assert (HasExplicit::Instances() == 1);
 176     delete two;
 177     assert (HasExplicit::Instances() == 0);
 178     HasExplicit::Assignments(0);
 179     assert (HasExplicit::Assignments() == 0);
 180 }
 181
 182 int
 183 main(int argc, char **argv)
 184 {
 185     CheckHasExplicitWorks();
 186     CheckSyntheticWorks();
 187     return 0;
 188 }