CoCalc -- test_java_arithmetic.cpp

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/hotspot/gtest/utilities/test_java_arithmetic.cpp
⁴¹¹⁴⁴ views
1
/*
2
 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#include "precompiled.hpp"
26
#include "memory/allocation.hpp"
27
#include "utilities/globalDefinitions.hpp"
28
#include "unittest.hpp"
29

30
class TestJavaArithSupport : public AllStatic {
31
public:
32
  template<typename T> struct BinOpData { T x; T y; T r; };
33
  template<typename T> struct ShiftOpData { T x; jint shift; T r; };
34
};
35

36
typedef TestJavaArithSupport::BinOpData<jint> BinOpJintData;
37
typedef TestJavaArithSupport::BinOpData<jlong> BinOpJlongData;
38

39
typedef TestJavaArithSupport::ShiftOpData<jint> ShiftOpJintData;
40
typedef TestJavaArithSupport::ShiftOpData<jlong> ShiftOpJlongData;
41

42
const BinOpJintData add_jint_data[] = {
43
  { 0, 0, 0 },
44
  { 0, 1, 1 },
45
  { 0, -1, -1 },
46
  { max_jint, 1, min_jint },
47
  { max_jint, -1, max_jint - 1 },
48
  { min_jint, 1, min_jint + 1 },
49
  { min_jint, -1, max_jint },
50
  { max_jint, 10, min_jint + 9 },
51
  { max_jint, -10, max_jint - 10 },
52
  { min_jint, 10, min_jint + 10 },
53
  { min_jint, -10, max_jint - 9 },
54
  { max_jint, max_jint, -2 },
55
  { min_jint, min_jint, 0 }
56
};
57

58
const BinOpJlongData add_jlong_data[] = {
59
  { 0, 0, 0 },
60
  { 0, 1, 1 },
61
  { 0, -1, -1 },
62
  { max_jlong, 1, min_jlong },
63
  { max_jlong, -1, max_jlong - 1 },
64
  { min_jlong, 1, min_jlong + 1 },
65
  { min_jlong, -1, max_jlong },
66
  { max_jlong, 10, min_jlong + 9 },
67
  { max_jlong, -10, max_jlong - 10 },
68
  { min_jlong, 10, min_jlong + 10 },
69
  { min_jlong, -10, max_jlong - 9 },
70
  { max_jlong, max_jlong, -2 },
71
  { min_jlong, min_jlong, 0 }
72
};
73

74
TEST(TestJavaArithmetic, add_sub_jint) {
75
  const volatile BinOpJintData* data = add_jint_data;
76
  for (size_t i = 0; i < ARRAY_SIZE(add_jint_data); ++i) {
77
    ASSERT_EQ(data[i].r, java_add(data[i].x, data[i].y));
78
    ASSERT_EQ(data[i].r, java_add(data[i].y, data[i].x));
79
    ASSERT_EQ(data[i].x, java_subtract(data[i].r, data[i].y));
80
    ASSERT_EQ(data[i].y, java_subtract(data[i].r, data[i].x));
81
  }
82
}
83

84
TEST(TestJavaArithmetic, add_sub_jlong) {
85
  const volatile BinOpJlongData* data = add_jlong_data;
86
  for (size_t i = 0; i < ARRAY_SIZE(add_jlong_data); ++i) {
87
    ASSERT_EQ(data[i].r, java_add(data[i].x, data[i].y));
88
    ASSERT_EQ(data[i].r, java_add(data[i].y, data[i].x));
89
    ASSERT_EQ(data[i].x, java_subtract(data[i].r, data[i].y));
90
    ASSERT_EQ(data[i].y, java_subtract(data[i].r, data[i].x));
91
  }
92
}
93

94
static const BinOpJintData mul_jint_data[] = {
95
  { 0, 0, 0 },
96
  { 0, 1, 0 },
97
  { 0, max_jint, 0 },
98
  { 0, min_jint, 0 },
99
  { 1, 1, 1 },
100
  { 1, max_jint, max_jint },
101
  { 1, min_jint, min_jint },
102
  { -1, 1, -1 },
103
  { -1, max_jint, min_jint + 1 },
104
  { 5, max_jint, max_jint - 4 },
105
  { -5, max_jint, min_jint + 5 },
106
  { max_jint, max_jint, 1 },
107
  { max_jint, min_jint, min_jint },
108
  { min_jint, min_jint, 0 }
109
};
110

111
static const BinOpJlongData mul_jlong_data[] = {
112
  { 0, 0, 0 },
113
  { 0, 1, 0 },
114
  { 0, max_jlong, 0 },
115
  { 0, min_jlong, 0 },
116
  { 1, 1, 1 },
117
  { 1, max_jlong, max_jlong },
118
  { 1, min_jlong, min_jlong },
119
  { -1, 1, -1 },
120
  { -1, max_jlong, min_jlong + 1 },
121
  { 5, max_jlong, max_jlong - 4 },
122
  { -5, max_jlong, min_jlong + 5 },
123
  { max_jlong, max_jlong, 1 },
124
  { max_jlong, min_jlong, min_jlong },
125
  { min_jlong, min_jlong, 0 }
126
};
127

128
TEST(TestJavaArithmetic, mul_jint) {
129
  const volatile BinOpJintData* data = mul_jint_data;
130
  for (size_t i = 0; i < ARRAY_SIZE(mul_jint_data); ++i) {
131
    ASSERT_EQ(data[i].r, java_multiply(data[i].x, data[i].y));
132
    ASSERT_EQ(data[i].r, java_multiply(data[i].y, data[i].x));
133
  }
134
}
135

136
TEST(TestJavaArithmetic, mul_jlong) {
137
  const volatile BinOpJlongData* data = mul_jlong_data;
138
  for (size_t i = 0; i < ARRAY_SIZE(mul_jlong_data); ++i) {
139
    ASSERT_EQ(data[i].r, java_multiply(data[i].x, data[i].y));
140
    ASSERT_EQ(data[i].r, java_multiply(data[i].y, data[i].x));
141
  }
142
}
143

144
static const ShiftOpJintData asl_jint_data[] = {
145
  { 0, 0, 0 },
146
  { 0, 10, 0 },
147
  { 0, 50, 0 },
148
  { 1, 0, 1 },
149
  { 1, 10, (jint)1 << 10 },
150
  { 1, 50, (jint)1 << 18 },
151
  { 5, 0, 5 },
152
  { 5, 10, (jint)5 << 10 },
153
  { 5, 50, (jint)5 << 18 },
154
  { -1, 0, -1 },
155
  { -1, 10, (jint)-1 * (1 << 10) },
156
  { -1, 50, (jint)-1 * (1 << 18) },
157
  { -5, 0, -5 },
158
  { -5, 10, (jint)-5 * (1 << 10) },
159
  { -5, 50, (jint)-5 * (1 << 18) },
160
  { max_jint, 0, max_jint },
161
  { max_jint, 10, (jint)0xFFFFFC00 },
162
  { max_jint, 50, (jint)0xFFFC0000 },
163
  { min_jint, 0, min_jint },
164
  { min_jint, 10, 0 },
165
  { min_jint, 50, 0 }
166
};
167

168
static const ShiftOpJlongData asl_jlong_data[] = {
169
  { 0, 0, 0 },
170
  { 0, 10, 0 },
171
  { 0, 82, 0 },
172
  { 1, 0, 1 },
173
  { 1, 10, (jlong)1 << 10 },
174
  { 1, 82, (jlong)1 << 18 },
175
  { 5, 0, 5 },
176
  { 5, 10, (jlong)5 << 10 },
177
  { 5, 82, (jlong)5 << 18 },
178
  { -1, 0, -1 },
179
  { -1, 10, (jlong)-1 * (1 << 10) },
180
  { -1, 82, (jlong)-1 * (1 << 18) },
181
  { -5, 0, -5 },
182
  { -5, 10, (jlong)-5 * (1 << 10) },
183
  { -5, 82, (jlong)-5 * (1 << 18) },
184
  { max_jlong, 0, max_jlong },
185
  { max_jlong, 10, (jlong)0xFFFFFFFFFFFFFC00 },
186
  { max_jlong, 82, (jlong)0xFFFFFFFFFFFC0000 },
187
  { min_jlong, 0, min_jlong },
188
  { min_jlong, 10, 0 },
189
  { min_jlong, 82, 0 }
190
};
191

192
TEST(TestJavaArithmetic, shift_left_jint) {
193
  const volatile ShiftOpJintData* data = asl_jint_data;
194
  for (size_t i = 0; i < ARRAY_SIZE(asl_jint_data); ++i) {
195
    ASSERT_EQ(data[i].r, java_shift_left(data[i].x, data[i].shift));
196
  }
197
}
198

199
TEST(TestJavaArithmetic, shift_left_jlong) {
200
  const volatile ShiftOpJlongData* data = asl_jlong_data;
201
  for (size_t i = 0; i < ARRAY_SIZE(asl_jlong_data); ++i) {
202
    ASSERT_EQ(data[i].r, java_shift_left(data[i].x, data[i].shift));
203
  }
204
}
205

206
static const ShiftOpJintData asr_jint_data[] = {
207
  { 0, 0, 0 },
208
  { 0, 10, 0 },
209
  { 0, 50, 0 },
210
  { 1, 0, 1 },
211
  { 1, 10, 0 },
212
  { 1, 50, 0 },
213
  { 5, 0, 5 },
214
  { 5, 1, 2 },
215
  { 5, 10, 0 },
216
  { 5, 33, 2 },
217
  { 5, 50, 0 },
218
  { -1, 0, -1 },
219
  { -1, 10, -1 },
220
  { -1, 50, -1 },
221
  { -5, 0, -5 },
222
  { -5, 1, -3 },
223
  { -5, 10, -1 },
224
  { -5, 33, -3 },
225
  { -5, 50, -1 },
226
  { max_jint, 0, max_jint },
227
  { max_jint, 10, (jint)0x001FFFFF },
228
  { max_jint, 50, (jint)0x00001FFF },
229
  { min_jint, 0, min_jint },
230
  { min_jint, 10, (jint)0xFFE00000 },
231
  { min_jint, 50, (jint)0xFFFFE000 }
232
};
233

234
static const ShiftOpJlongData asr_jlong_data[] = {
235
  { 0, 0, 0 },
236
  { 0, 10, 0 },
237
  { 0, 82, 0 },
238
  { 1, 0, 1 },
239
  { 1, 10, 0 },
240
  { 1, 82, 0 },
241
  { 5, 0, 5 },
242
  { 5, 1, 2 },
243
  { 5, 10, 0 },
244
  { 5, 65, 2 },
245
  { 5, 82, 0 },
246
  { -1, 0, -1 },
247
  { -1, 10, -1 },
248
  { -1, 82, -1 },
249
  { -5, 0, -5 },
250
  { -5, 1, -3 },
251
  { -5, 10, -1 },
252
  { -5, 65, -3 },
253
  { -5, 82, -1 },
254
  { max_jlong, 0, max_jlong },
255
  { max_jlong, 10, (jlong)0x001FFFFFFFFFFFFF },
256
  { max_jlong, 82, (jlong)0x00001FFFFFFFFFFF },
257
  { min_jlong, 0, min_jlong },
258
  { min_jlong, 10, (jlong)0xFFE0000000000000 },
259
  { min_jlong, 82, (jlong)0xFFFFE00000000000 }
260
};
261

262
TEST(TestJavaArithmetic, shift_right_jint) {
263
  const volatile ShiftOpJintData* data = asr_jint_data;
264
  for (size_t i = 0; i < ARRAY_SIZE(asr_jint_data); ++i) {
265
    ASSERT_EQ(data[i].r, java_shift_right(data[i].x, data[i].shift));
266
  }
267
}
268

269
TEST(TestJavaArithmetic, shift_right_jlong) {
270
  const volatile ShiftOpJlongData* data = asr_jlong_data;
271
  for (size_t i = 0; i < ARRAY_SIZE(asr_jlong_data); ++i) {
272
    ASSERT_EQ(data[i].r, java_shift_right(data[i].x, data[i].shift));
273
  }
274
}
275

276
static const ShiftOpJintData lsr_jint_data[] = {
277
  { 0, 0, 0 },
278
  { 0, 10, 0 },
279
  { 0, 50, 0 },
280
  { 1, 0, 1 },
281
  { 1, 10, 0 },
282
  { 1, 50, 0 },
283
  { 5, 0, 5 },
284
  { 5, 1, 2 },
285
  { 5, 10, 0 },
286
  { 5, 33, 2 },
287
  { 5, 50, 0 },
288
  { -1, 0, -1 },
289
  { -1, 10, (jint)0x003FFFFF },
290
  { -1, 50, (jint)0x00003FFF },
291
  { -5, 0, -5 },
292
  { -5, 1, (jint)0x7FFFFFFD },
293
  { -5, 10, (jint)0x003FFFFF },
294
  { -5, 50, (jint)0x00003FFF },
295
  { max_jint, 0, max_jint },
296
  { max_jint, 1, (jint)0x3FFFFFFF },
297
  { max_jint, 10, (jint)0x001FFFFF },
298
  { max_jint, 50, (jint)0x00001FFF },
299
  { min_jint, 0, min_jint },
300
  { min_jint, 1, (jint)0x40000000 },
301
  { min_jint, 10, (jint)0x00200000 },
302
  { min_jint, 50, (jint)0x00002000 }
303
};
304

305
static const ShiftOpJlongData lsr_jlong_data[] = {
306
  { 0, 0, 0 },
307
  { 0, 10, 0 },
308
  { 0, 82, 0 },
309
  { 1, 0, 1 },
310
  { 1, 10, 0 },
311
  { 1, 82, 0 },
312
  { 5, 0, 5 },
313
  { 5, 1, 2 },
314
  { 5, 10, 0 },
315
  { 5, 65, 2 },
316
  { 5, 82, 0 },
317
  { -1, 0, -1 },
318
  { -1, 10, (jlong)0x003FFFFFFFFFFFFF },
319
  { -1, 82, (jlong)0x00003FFFFFFFFFFF },
320
  { -5, 0, -5 },
321
  { -5, 1, (jlong)0x7FFFFFFFFFFFFFFD },
322
  { -5, 10, (jlong)0x003FFFFFFFFFFFFF },
323
  { -5, 82, (jlong)0x00003FFFFFFFFFFF },
324
  { max_jlong, 0, max_jlong },
325
  { max_jlong, 1, (jlong)0x3FFFFFFFFFFFFFFF },
326
  { max_jlong, 10, (jlong)0x001FFFFFFFFFFFFF },
327
  { max_jlong, 82, (jlong)0x00001FFFFFFFFFFF },
328
  { min_jlong, 0, min_jlong },
329
  { min_jlong, 1, (jlong)0x4000000000000000 },
330
  { min_jlong, 10, (jlong)0x0020000000000000 },
331
  { min_jlong, 82, (jlong)0x0000200000000000 }
332
};
333

334
TEST(TestJavaArithmetic, shift_right_unsigned_jint) {
335
  const volatile ShiftOpJintData* data = lsr_jint_data;
336
  for (size_t i = 0; i < ARRAY_SIZE(lsr_jint_data); ++i) {
337
    ASSERT_EQ(data[i].r, java_shift_right_unsigned(data[i].x, data[i].shift));
338
  }
339
}
340

341
TEST(TestJavaArithmetic, shift_right_unsigned_jlong) {
342
  const volatile ShiftOpJlongData* data = lsr_jlong_data;
343
  for (size_t i = 0; i < ARRAY_SIZE(lsr_jlong_data); ++i) {
344
    ASSERT_EQ(data[i].r, java_shift_right_unsigned(data[i].x, data[i].shift));
345
  }
346
}
347

348
Product

Resources

Company
