1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// $Id$
// ============================================================================
//
// = LIBRARY
// tests
//
// = FILENAME
// Dynamic_Test.cpp
//
// = DESCRIPTION
// This tests the ACE_Dynamic class
//
// = AUTHORS
// Johnny Willemsen <jwillemsen@remedy.nl>
//
// ============================================================================
#include "test_config.h"
#include "ace/OS_NS_string.h"
#include "ace/Dynamic.h"
#include "ace/OS_Memory.h"
ACE_RCSID(tests, Dynamic_Test, "$Id$")
class A
{
public:
A ();
void *operator new (size_t n);
#if defined (ACE_HAS_NEW_NOTHROW)
void *operator new (size_t n, const ACE_nothrow_t&) throw();
#if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
void operator delete (void *p, const ACE_nothrow_t&) throw ();
#endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
#endif
void * operator new (size_t n, void *p);
void operator delete (void *);
#if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
void operator delete (void *, void *);
#endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
/// Have we been dynamically created?
bool dynamic_;
};
void*
A::operator new (size_t n)
{
ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
if (dynamic_instance == 0)
{
// If this ACE_ASSERT fails, it may be due to running of out TSS
// keys. Try using ACE_HAS_TSS_EMULATION, or increasing
// ACE_DEFAULT_THREAD_KEYS if already using TSS emulation.
ACE_ASSERT (dynamic_instance != 0);
ACE_throw_bad_alloc;
}
else
{
// Allocate the memory and store it (usually in thread-specific
// storage, depending on config flags).
dynamic_instance->set ();
return ::new char[n];
}
}
#if defined (ACE_HAS_NEW_NOTHROW)
void*
A::operator new (size_t n, const ACE_nothrow_t&) throw()
{
ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
if (dynamic_instance == 0)
{
// If this ACE_ASSERT fails, it may be due to running of out TSS
// keys. Try using ACE_HAS_TSS_EMULATION, or increasing
// ACE_DEFAULT_THREAD_KEYS if already using TSS emulation.
ACE_ASSERT (dynamic_instance != 0);
return 0;
}
else
{
// Allocate the memory and store it (usually in thread-specific
// storage, depending on config flags).
dynamic_instance->set ();
return ::new(ACE_nothrow) char[n];
}
}
#if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
void
A::operator delete (void *p, const ACE_nothrow_t&) throw()
{
::delete [] static_cast <char *> (p);
}
#endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
#endif /* ACE_HAS_NEW_NOTHROW */
void
A::operator delete (void *obj)
{
::delete [] static_cast <char *> (obj);
}
A::A()
{
this->dynamic_ = ACE_Dynamic::instance ()->is_dynamic ();
if (this->dynamic_)
// Make sure to reset the flag.
ACE_Dynamic::instance ()->reset ();
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Dynamic_Test")); {
A from_stack;
A* heap = 0;
ACE_NEW_RETURN (heap, A, 1);
if (from_stack.dynamic_)
{
ACE_OS::printf ("ERROR1\n");
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("dynamic_ is true for an object on the stack\n")),
1);
}
else
ACE_OS::printf ("OK1\n");
if (!heap->dynamic_)
{
ACE_OS::printf ("ERROR2\n");
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("dynamic_ is false for an object from the heap\n")),
1);
}
else
ACE_OS::printf ("OK2\n");
delete heap;
}
ACE_END_TEST;
return 0;
}
|
