From 232069aa00536d6b7ab1b4c5f21e95247941af92 Mon Sep 17 00:00:00 2001
From: Douglas Gregor <doug.gregor@gmail.com>
Date: Mon, 5 Aug 2002 06:13:32 +0000
Subject: [PATCH] allocator_test.cpp:   - Remove partial
 specialization-specific code

function_test.cpp:
  - Uses BOOST_FUNCTION_NO_DEPRECATED
  - Use only the new syntax
  - Test the allocator parameter

deprecated_syntax_test.cpp:
  - Test the deprecated syntax


[SVN r14684]
---
 test/allocator_test.cpp         |  12 -
 test/deprecated_syntax_test.cpp | 645 ++++++++++++++++++++++++++++++++
 test/function_test.cpp          | 125 ++++---
 3 files changed, 725 insertions(+), 57 deletions(-)
 create mode 100644 test/deprecated_syntax_test.cpp

diff --git a/test/allocator_test.cpp b/test/allocator_test.cpp
index 71dddcc..cab749f 100644
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@@ -84,17 +84,5 @@ test_main(int, char*[])
   fv = &do_nothing;
   fv.clear();
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  typedef int Ftype(int, int);
-  function<Ftype, empty_function_policy, empty_function_mixin,
-           counting_allocator<int> > f2;
-  alloc_count = 0;
-  dealloc_count = 0;
-  f2 = plus<int>();
-  f2.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-#endif
-
   return 0;
 }
diff --git a/test/deprecated_syntax_test.cpp b/test/deprecated_syntax_test.cpp
new file mode 100644
index 0000000..645d719
--- /dev/null
+++ b/test/deprecated_syntax_test.cpp
@@ -0,0 +1,645 @@
+// Boost.Function library
+
+// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://www.boost.org
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <boost/function.hpp>
+#include <functional>
+#include <cassert>
+#include <string>
+
+using namespace boost;
+using std::string;
+using std::negate;
+
+int global_int;
+
+struct write_five_obj { void operator()() const { global_int = 5; } };
+struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
+static void write_five() { global_int = 5; }
+static void write_three() { global_int = 3; }
+struct generate_five_obj { int operator()() const { return 5; } };
+struct generate_three_obj { int operator()() const { return 3; } };
+static int generate_five() { return 5; }
+static int generate_three() { return 3; }
+static string identity_str(const string& s) { return s; }
+static string string_cat(const string& s1, const string& s2) { return s1+s2; }
+static int sum_ints(int x, int y) { return x+y; }
+
+struct write_const_1_nonconst_2
+{
+  void operator()() { global_int = 2; }
+  void operator()() const { global_int = 1; }
+};
+
+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
+static void
+test_zero_args()
+{
+  typedef function<void> func_void_type;
+
+  write_five_obj five;
+  write_three_obj three;
+
+  // Default construction
+  func_void_type v1;
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function 
+  v1 = five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation of a function
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v1.clear();
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function
+  v1 = three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = v1;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v1 = five;
+
+  // Invocation and self-assignment
+  global_int = 0;
+  v1 = (v1);
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v1.clear();
+  BOOST_TEST(v1.empty());
+
+  // Assignment to an empty function from a free function
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v1 = five;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v1 = &write_three;
+  BOOST_TEST(!v1.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+
+  // Construction from another function (that is empty)
+  v1.clear();
+  func_void_type v2(v1);
+  BOOST_TEST(!v2);
+
+  // Assignment to an empty function
+  v2 = three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v2 = (five);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  v2.clear();
+  BOOST_TEST(v2.empty());
+
+  // Assignment to an empty function from a free function
+  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
+  BOOST_TEST(v2);
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Swapping
+  v1 = five;
+  swap(v1, v2);
+  v2();
+  BOOST_TEST(global_int == 5);
+  v1();
+  BOOST_TEST(global_int == 3);
+  swap(v1, v2);
+  v1.clear();
+
+  // Assignment
+  v2 = five;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v2 = &write_three;
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a function from an empty function
+  v2 = v1;
+  BOOST_TEST(v2.empty()); 
+  
+  // Assignment to a function from a function with a functor
+  v1 = three;
+  v2 = v1;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+
+  // Invocation
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 3);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 3);
+
+  // Assign to a function from a function with a function
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
+  v1 = v2;
+  BOOST_TEST(!v1.empty());
+  BOOST_TEST(!v2.empty());
+  global_int = 0;
+  v1();
+  BOOST_TEST(global_int == 5);
+  global_int = 0;
+  v2();
+  BOOST_TEST(global_int == 5);
+
+  // Construct a function given another function containing a function
+  func_void_type v3(v1);
+
+  // Invocation of a function
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+  
+  // clear() method
+  v3.clear();
+  BOOST_TEST(!v3);
+
+  // Assignment to an empty function
+  v3 = three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v3 = five;
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v3.clear();
+  BOOST_TEST(v3.empty());
+
+  // Assignment to an empty function from a free function
+  v3 = &write_five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v3 = &write_three;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v3 = five;
+  BOOST_TEST(!v3.empty());
+
+  // Invocation
+  global_int = 0;
+  v3();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a function containing a functor
+  func_void_type v4(v3);
+
+  // Invocation of a function
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+  
+  // clear() method
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function
+  v4 = three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v4 = five;
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v4.clear();
+  BOOST_TEST(v4.empty());
+
+  // Assignment to an empty function from a free function
+  v4 = &write_five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v4 = &write_three;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v4 = five;
+  BOOST_TEST(!v4.empty());
+
+  // Invocation
+  global_int = 0;
+  v4();
+  BOOST_TEST(global_int == 5);
+
+  // Construction of a function from a functor
+  func_void_type v5(five);
+
+  // Invocation of a function
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+  
+  // clear() method
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function
+  v5 = three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v5 = five;
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v5.clear();
+  BOOST_TEST(v5.empty());
+
+  // Assignment to an empty function from a free function
+  v5 = &write_five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v5 = &write_three;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v5 = five;
+  BOOST_TEST(!v5.empty());
+
+  // Invocation
+  global_int = 0;
+  v5();
+  BOOST_TEST(global_int == 5);  
+
+  // Construction of a function from a function
+  func_void_type v6(&write_five);
+
+  // Invocation of a function
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear() method
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function
+  v6 = three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment to a non-empty function
+  v6 = five;
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // clear()
+  v6.clear();
+  BOOST_TEST(v6.empty());
+
+  // Assignment to an empty function from a free function
+  v6 = &write_five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);
+
+  // Assignment to a non-empty function from a free function
+  v6 = &write_three;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 3);
+
+  // Assignment
+  v6 = five;
+  BOOST_TEST(!v6.empty());
+
+  // Invocation
+  global_int = 0;
+  v6();
+  BOOST_TEST(global_int == 5);  
+
+  // Const vs. non-const
+  write_const_1_nonconst_2 one_or_two;
+  const function<void> v7(one_or_two);
+  function <void> v8(one_or_two);
+
+  global_int = 0;
+  v7();
+  BOOST_TEST(global_int == 2);
+  
+  global_int = 0;
+  v8();
+  BOOST_TEST(global_int == 2);
+
+  // Test return values
+  typedef function<int> func_int_type;
+  generate_five_obj gen_five;
+  generate_three_obj gen_three;
+
+  func_int_type i0(gen_five);
+
+  BOOST_TEST(i0() == 5);
+  i0 = gen_three;
+  BOOST_TEST(i0() == 3);
+  i0 = &generate_five;
+  BOOST_TEST(i0() == 5);
+  i0 = &generate_three;
+  BOOST_TEST(i0() == 3);
+  BOOST_TEST(i0);
+  i0.clear();
+  BOOST_TEST(!i0);
+
+  // Test return values with compatible types
+  typedef function<long> func_long_type;
+  func_long_type i1(gen_five);
+
+  BOOST_TEST(i1() == 5);
+  i1 = gen_three;
+  BOOST_TEST(i1() == 3);
+  i1 = &generate_five;
+  BOOST_TEST(i1() == 5);
+  i1 = &generate_three;
+  BOOST_TEST(i1() == 3);
+  BOOST_TEST(i1);
+  i1.clear();
+  BOOST_TEST(!i1);
+}
+
+static void
+test_one_arg()
+{
+  negate<int> neg;
+
+  function<int, int> f1(neg);
+  BOOST_TEST(f1(5) == -5);
+
+  function<string, string> id(&identity_str);
+  BOOST_TEST(id("str") == "str");
+
+  function<std::string, const char*> id2(&identity_str);
+  BOOST_TEST(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function<int, int> f2(add_to);
+  BOOST_TEST(f2(3) == 8);
+
+  const function<int, int> cf2(add_to);
+  BOOST_TEST(cf2(3) == 8);
+}
+
+static void
+test_two_args()
+{
+  function<string, const string&, const string&> cat(&string_cat);
+  BOOST_TEST(cat("str", "ing") == "string");  
+
+  function<int, short, short> sum(&sum_ints);
+  BOOST_TEST(sum(2, 3) == 5);
+}
+
+static void
+test_emptiness()
+{
+  function<float> f1;
+  BOOST_TEST(f1.empty());
+
+  function<float> f2;
+  f2 = f1;
+  BOOST_TEST(f2.empty());
+
+  function<double> f3;
+  f3 = f2;
+  BOOST_TEST(f3.empty());
+}
+
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+  boost::function<int, X*> f1(&X::twice);
+  
+  X one(1);
+  X five(5);
+
+  BOOST_TEST(f1(&one) == 2);
+  BOOST_TEST(f1(&five) == 10);
+
+  boost::function<int, X*> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_TEST(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&five) == 10);
+
+  boost::function<int, X&, int> f2(&X::plus);
+  BOOST_TEST(f2(one, 3) == 4);
+  BOOST_TEST(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function<int, int, int> f(ref(atc));
+    BOOST_TEST(f(1, 3) == 4);
+  }
+  catch(std::runtime_error e) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+int test_main(int, char* [])
+{
+  test_zero_args();
+  test_one_arg();
+  test_two_args();
+  test_emptiness();
+  test_member_functions();
+  test_ref();
+
+  return 0;
+}
diff --git a/test/function_test.cpp b/test/function_test.cpp
index 166d1e6..861dec0 100644
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@@ -14,6 +14,7 @@
 // For more information, see http://www.boost.org
 
 #define BOOST_INCLUDE_MAIN
+#define BOOST_FUNCTION_NO_DEPRECATED
 #include <boost/test/test_tools.hpp>
 #include <boost/function.hpp>
 #include <functional>
@@ -21,8 +22,7 @@
 #include <string>
 
 using namespace boost;
-using std::string;
-using std::negate;
+using namespace std;
 
 int global_int;
 
@@ -56,7 +56,7 @@ struct add_to_obj
 static void
 test_zero_args()
 {
-  typedef function<void> func_void_type;
+  typedef function<void ()> func_void_type;
 
   write_five_obj five;
   write_three_obj three;
@@ -480,8 +480,8 @@ test_zero_args()
 
   // Const vs. non-const
   write_const_1_nonconst_2 one_or_two;
-  const function<void> v7(one_or_two);
-  function <void> v8(one_or_two);
+  const function<void ()> v7(one_or_two);
+  function<void ()> v8(one_or_two);
 
   global_int = 0;
   v7();
@@ -492,7 +492,7 @@ test_zero_args()
   BOOST_TEST(global_int == 2);
 
   // Test return values
-  typedef function<int> func_int_type;
+  typedef function<int ()> func_int_type;
   generate_five_obj gen_five;
   generate_three_obj gen_three;
 
@@ -510,7 +510,7 @@ test_zero_args()
   BOOST_TEST(!i0);
 
   // Test return values with compatible types
-  typedef function<long> func_long_type;
+  typedef function<long ()> func_long_type;
   func_long_type i1(gen_five);
 
   BOOST_TEST(i1() == 5);
@@ -530,44 +530,44 @@ test_one_arg()
 {
   negate<int> neg;
 
-  function<int, int> f1(neg);
+  function<int (int)> f1(neg);
   BOOST_TEST(f1(5) == -5);
 
-  function<string, string> id(&identity_str);
+  function<string (string)> id(&identity_str);
   BOOST_TEST(id("str") == "str");
 
-  function<std::string, const char*> id2(&identity_str);
+  function<string (const char*)> id2(&identity_str);
   BOOST_TEST(id2("foo") == "foo");
 
   add_to_obj add_to(5);
-  function<int, int> f2(add_to);
+  function<int (int)> f2(add_to);
   BOOST_TEST(f2(3) == 8);
 
-  const function<int, int> cf2(add_to);
+  const function<int (int)> cf2(add_to);
   BOOST_TEST(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
-  function<string, const string&, const string&> cat(&string_cat);
+  function<string (const string&, const string&)> cat(&string_cat);
   BOOST_TEST(cat("str", "ing") == "string");  
 
-  function<int, short, short> sum(&sum_ints);
+  function<int (short, short)> sum(&sum_ints);
   BOOST_TEST(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
-  function<float> f1;
+  function<float ()> f1;
   BOOST_TEST(f1.empty());
 
-  function<float> f2;
+  function<float ()> f2;
   f2 = f1;
   BOOST_TEST(f2.empty());
 
-  function<double> f3;
+  function<double ()> f3;
   f3 = f2;
   BOOST_TEST(f3.empty());
 }
@@ -584,7 +584,7 @@ struct X {
 static void
 test_member_functions()
 {
-  boost::function<int, X*> f1(&X::twice);
+  boost::function<int (X*)> f1(&X::twice);
   
   X one(1);
   X five(5);
@@ -592,13 +592,13 @@ test_member_functions()
   BOOST_TEST(f1(&one) == 2);
   BOOST_TEST(f1(&five) == 10);
 
-  boost::function<int, X*> f1_2;
+  boost::function<int (X*)> f1_2;
   f1_2 = &X::twice;
 
   BOOST_TEST(f1_2(&one) == 2);
   BOOST_TEST(f1_2(&five) == 10);
 
-  boost::function<int, X&, int> f2(&X::plus);
+  boost::function<int (X&, int)> f2(&X::plus);
   BOOST_TEST(f2(one, 3) == 4);
   BOOST_TEST(f2(five, 4) == 9);
 }
@@ -610,12 +610,12 @@ struct add_with_throw_on_copy {
 
   add_with_throw_on_copy(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 
   add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 };
 
@@ -624,39 +624,74 @@ test_ref()
 {
   add_with_throw_on_copy atc;
   try {
-    boost::function<int, int, int> f(ref(atc));
+    boost::function<int (int, int)> f(ref(atc));
     BOOST_TEST(f(1, 3) == 4);
   }
-  catch(std::runtime_error e) {
+  catch(runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
 
-static void
-test_new_syntax()
+static int alloc_count = 0;
+static int dealloc_count = 0;
+
+template<typename T>
+struct counting_allocator : public allocator<T>
 {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  write_five_obj five;
-  typedef void F2();
-  function<F2> v2;
+  template<typename U>
+  struct rebind
+  {
+    typedef counting_allocator<U> other;
+  };
 
-  // Assignment
-  v2 = five;
-  BOOST_TEST(!v2.empty());
+  
+  T* allocate(size_t n)
+  {
+    alloc_count++;
+    return allocator<T>::allocate(n);
+  }
 
-  // Invocation
-  global_int = 0;
-  v2();
+  void deallocate(T* p, size_t n)
+  {
+    dealloc_count++;
+    allocator<T>::deallocate(p, n);
+  }
+};
 
-  BOOST_TEST(global_int == 5);
-  typedef string Fcat(const string& x, const string& y);
-  function<Fcat> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");  
+static int do_minus(int x, int y) { return x-y; }
 
-  typedef int Fsum(short lhs, short rhs);
-  function<Fsum> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
-#endif
+struct DoNothing
+{
+  void operator()() const {}
+};
+
+static void do_nothing() {}
+
+static void test_allocator()
+{
+  boost::function<int (int, int), counting_allocator<int> > f;
+  f = plus<int>();
+  f.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  f = &do_minus;
+  f.clear();
+
+  boost::function<void (), counting_allocator<int> > fv;
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = DoNothing();
+  fv.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+  
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = &do_nothing;
+  fv.clear();
 }
 
 int test_main(int, char* [])
@@ -667,7 +702,7 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
-  test_new_syntax();
+  test_allocator();
 
   return 0;
 }