1 /* -*- c++ -*- */
2 /*
3 * Copyright (C) 2009 The Android Open Source Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
19 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
20 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
23 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30
31 #include "../include/memory"
32 #ifndef ANDROID_ASTL_MEMORY__
33 #error "Wrong header included!!"
34 #endif
35 #include "common.h"
36 #include <algorithm>
37 #include <cstdlib>
38
39 namespace android {
40 using std::uninitialized_copy;
41 using std::uninitialized_fill;
42
testCopyPod()43 bool testCopyPod()
44 {
45 {
46 int src[0];
47 const int size = ARRAYSIZE(src);
48 int dest[10] = {0, };
49 EXPECT_TRUE(uninitialized_copy(src, src + size, dest) == dest);
50 }
51 {
52 int src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
53 const int size = ARRAYSIZE(src);
54 int dest[size] = {0, };
55
56 EXPECT_TRUE(uninitialized_copy(src, src + size, dest) == dest + size);
57
58 EXPECT_TRUE(std::equal(src, src + size, dest));
59 }
60 return true;
61 }
62
63
testCopyPodOverflow()64 bool testCopyPodOverflow()
65 {
66 int src, dest;
67
68 // Should not crash
69 EXPECT_TRUE(
70 uninitialized_copy(&src, &src + kMaxSizeT / sizeof(src) + 1, &dest) ==
71 &dest);
72 return true;
73 }
74
testCopyClass()75 bool testCopyClass()
76 {
77 const size_t kSize = 100;
78 CtorDtorCounter::reset();
79
80 CtorDtorCounter src[kSize];
81 CtorDtorCounter *dest = static_cast<CtorDtorCounter*>(
82 malloc(kSize * sizeof(CtorDtorCounter)));
83
84 EXPECT_TRUE(CtorDtorCounter::mCtorCount == kSize);
85 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
86 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
87
88 CtorDtorCounter::reset();
89
90 EXPECT_TRUE(uninitialized_copy(src, src + kSize, dest) == dest + kSize);
91
92 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
93 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == kSize);
94 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
95 free(dest);
96 return true;
97 }
98
99 struct A {};
testCopyArray()100 bool testCopyArray()
101 {
102 {
103 A src[0];
104 A one;
105 A *dest = &one;
106 // Empty, dest should not have moved.
107 EXPECT_TRUE(uninitialized_copy(src, src, dest) == dest);
108 }
109 {
110 const A src[] = {A()};
111 A one;
112 A *dest = &one;
113
114 EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest + 1);
115 }
116 {
117 A src[] = {A()};
118 A one;
119 A *dest = &one;
120
121 EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest + 1);
122 }
123 {
124 const A src[] = {A()};
125 A dest[1];
126
127 EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest + 1);
128 }
129 return true;
130 }
131
testFillChar()132 bool testFillChar()
133 {
134 const char src[] = {'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a'};
135 const int size = ARRAYSIZE(src);
136 char dest[size];
137
138 uninitialized_fill(dest, dest + size, 'a');
139
140 EXPECT_TRUE(std::equal(dest, dest + size, src));
141 return true;
142 }
143
testFillPod()144 bool testFillPod()
145 {
146 const int src[] = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
147 const int size = ARRAYSIZE(src);
148 int dest[size];
149
150 uninitialized_fill(dest, dest + size, 10);
151
152 EXPECT_TRUE(std::equal(dest, dest + size, src));
153 return true;
154 }
155
testFillClass()156 bool testFillClass()
157 {
158 const size_t kSize = 100;
159 CtorDtorCounter::reset();
160
161 CtorDtorCounter src;
162 CtorDtorCounter *dest = static_cast<CtorDtorCounter*>(
163 malloc(kSize * sizeof(CtorDtorCounter)));
164
165 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 1);
166 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
167 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
168
169 CtorDtorCounter::reset();
170
171 uninitialized_fill(dest, dest + kSize, src);
172
173 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
174 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == kSize);
175 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
176 free(dest);
177 return true;
178 }
179
180
181 } // namespace android
182
main(int argc,char ** argv)183 int main(int argc, char **argv)
184 {
185 // copy
186 FAIL_UNLESS(testCopyPod);
187 FAIL_UNLESS(testCopyPodOverflow);
188 FAIL_UNLESS(testCopyClass);
189 FAIL_UNLESS(testCopyArray);
190 // fill
191 FAIL_UNLESS(testFillChar);
192 FAIL_UNLESS(testFillPod);
193 FAIL_UNLESS(testFillClass);
194
195 return kPassed;
196 }
197