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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
|
/*
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @bug 8277451
* @run testng/othervm -Djdk.reflect.useDirectMethodHandle=true NegativeTest
* @run testng/othervm -Djdk.reflect.useDirectMethodHandle=false NegativeTest
* @summary Test exception thrown due to bad receiver and bad value on
* Field with and without setAccessible(true)
*/
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
public class NegativeTest {
static class Fields {
public static int si;
public static char sc;
public static byte sb;
public static short ss;
public static long sl;
public static double sd;
public static float sf;
public static boolean sz;
public static String so;
public static final int sfi = 10;
public static final char sfc = 'a';
public static final byte sfb = 1;
public static final short sfs = 2;
public static final long sfl = 1000L;
public static final double sfd = 1.0;
public static final float sff = 2.0f;
public static final boolean sfz = true;
public static final String sfo = "abc";
public int i;
public char c;
public byte b;
public short s;
public long l;
public double d;
public float f;
public boolean z;
public String o;
public final int fi = 10;
public final char fc = 'a';
public final byte fb = 1;
public final short fs = 2;
public final long fl = 1000L;
public final double fd = 1.0;
public final float ff = 2.0f;
public final boolean fz = true;
public final String fo = "abc";
}
static final Field i_field = field("i", false);
static final Field c_field = field("c", false);
static final Field b_field = field("b", false);
static final Field s_field = field("s", false);
static final Field l_field = field("l", false);
static final Field d_field = field("d", false);
static final Field f_field = field("f", false);
static final Field z_field = field("z", false);
static final Field o_field = field("o", false);
static final Field fi_field = field("fi", false);
static final Field fc_field = field("fc", false);
static final Field fb_field = field("fb", false);
static final Field fs_field = field("fs", false);
static final Field fl_field = field("fl", false);
static final Field fd_field = field("fd", false);
static final Field ff_field = field("ff", false);
static final Field fz_field = field("fz", false);
static final Field fo_field = field("fo", false);
static final Field override_i_field = field("i", true);
static final Field override_c_field = field("c", true);
static final Field override_b_field = field("b", true);
static final Field override_s_field = field("s", true);
static final Field override_l_field = field("l", true);
static final Field override_d_field = field("d", true);
static final Field override_f_field = field("f", true);
static final Field override_z_field = field("z", true);
static final Field override_o_field = field("o", true);
static final Field override_fi_field = field("fi", true);
static final Field override_fc_field = field("fc", true);
static final Field override_fb_field = field("fb", true);
static final Field override_fs_field = field("fs", true);
static final Field override_fl_field = field("fl", true);
static final Field override_fd_field = field("fd", true);
static final Field override_ff_field = field("ff", true);
static final Field override_fz_field = field("fz", true);
static final Field override_fo_field = field("fo", true);
static final Field si_field = field("si", false);
static final Field sc_field = field("sc", false);
static final Field sb_field = field("sb", false);
static final Field ss_field = field("ss", false);
static final Field sl_field = field("sl", false);
static final Field sd_field = field("sd", false);
static final Field sf_field = field("sf", false);
static final Field sz_field = field("sz", false);
static final Field so_field = field("so", false);
static final Field sfi_field = field("sfi", false);
static final Field sfc_field = field("sfc", false);
static final Field sfb_field = field("sfb", false);
static final Field sfs_field = field("sfs", false);
static final Field sfl_field = field("sfl", false);
static final Field sfd_field = field("sfd", false);
static final Field sff_field = field("sff", false);
static final Field sfz_field = field("sfz", false);
static final Field sfo_field = field("sfo", false);
static final Field override_si_field = field("si", true);
static final Field override_sc_field = field("sc", true);
static final Field override_sb_field = field("sb", true);
static final Field override_ss_field = field("ss", true);
static final Field override_sl_field = field("sl", true);
static final Field override_sd_field = field("sd", true);
static final Field override_sf_field = field("sf", true);
static final Field override_sz_field = field("sz", true);
static final Field override_so_field = field("so", true);
static final Field override_sfi_field = field("sfi", true);
static final Field override_sfc_field = field("sfc", true);
static final Field override_sfb_field = field("sfb", true);
static final Field override_sfs_field = field("sfs", true);
static final Field override_sfl_field = field("sfl", true);
static final Field override_sfd_field = field("sfd", true);
static final Field override_sff_field = field("sff", true);
static final Field override_sfz_field = field("sfz", true);
static final Field override_sfo_field = field("sfo", true);
private static Field field(String name, boolean suppressAccessCheck) {
try {
Field f = Fields.class.getDeclaredField(name);
if (suppressAccessCheck) {
f.setAccessible(true);
}
return f;
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
@DataProvider(name = "instanceFields")
private Object[][] instanceFields() {
return new Object[][]{
new Object[]{i_field},
new Object[]{c_field},
new Object[]{b_field},
new Object[]{s_field},
new Object[]{l_field},
new Object[]{d_field},
new Object[]{f_field},
new Object[]{z_field},
new Object[]{o_field},
new Object[]{override_i_field},
new Object[]{override_c_field},
new Object[]{override_b_field},
new Object[]{override_s_field},
new Object[]{override_l_field},
new Object[]{override_d_field},
new Object[]{override_f_field},
new Object[]{override_z_field},
new Object[]{override_o_field},
// final instance fields
new Object[]{fi_field},
new Object[]{fc_field},
new Object[]{fb_field},
new Object[]{fs_field},
new Object[]{fl_field},
new Object[]{fd_field},
new Object[]{ff_field},
new Object[]{fz_field},
new Object[]{fo_field},
new Object[]{override_fi_field},
new Object[]{override_fc_field},
new Object[]{override_fb_field},
new Object[]{override_fs_field},
new Object[]{override_fl_field},
new Object[]{override_fd_field},
new Object[]{override_ff_field},
new Object[]{override_fz_field},
new Object[]{override_fo_field},
};
}
private static Fields INSTANCE = new Fields();
/*
* Test Field::get on a good receiver, a bad receiver and null.
*
* IllegalArgumentException is thrown if the receiver is of
* a bad type. NullPointerException is thrown if the receiver is null.
*/
@Test(dataProvider = "instanceFields")
public void testReceiver(Field f) throws ReflectiveOperationException {
f.get(INSTANCE); // good receiver
testBadReceiver(f);
testNullReceiver(f);
}
/*
* IllegalArgumentException should be thrown for bad receiver type
*/
private void testBadReceiver(Field f) throws ReflectiveOperationException {
assertFalse(Modifier.isStatic(f.getModifiers())); // instance field
Object badObj = new NegativeTest();
try {
f.get(badObj);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
Class<?> fType = f.getType();
if (fType.isPrimitive()) {
try {
switch (fType.descriptorString()) {
case "B" -> f.getByte(badObj);
case "C" -> f.getChar(badObj);
case "D" -> f.getDouble(badObj);
case "F" -> f.getFloat(badObj);
case "I" -> f.getInt(badObj);
case "J" -> f.getLong(badObj);
case "S" -> f.getShort(badObj);
case "Z" -> f.getBoolean(badObj);
}
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
}
/*
* NullPointerException should be thrown for null receiver
*/
private void testNullReceiver(Field f) throws ReflectiveOperationException {
assertFalse(Modifier.isStatic(f.getModifiers())); // instance field
try {
f.get(null);
fail("expected NullPointerException");
} catch (NullPointerException e) {
// expected
}
Class<?> fType = f.getType();
if (fType.isPrimitive()) {
try {
switch (fType.descriptorString()) {
case "B" -> f.getByte(null);
case "C" -> f.getChar(null);
case "D" -> f.getDouble(null);
case "F" -> f.getFloat(null);
case "I" -> f.getInt(null);
case "J" -> f.getLong(null);
case "S" -> f.getShort(null);
case "Z" -> f.getBoolean(null);
}
fail("expected NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
}
@DataProvider(name = "writeableFields")
private Object[][] writeableFields() {
Fields obj = new Fields();
return new Object[][]{
// instance fields with and without setAccessible(true)
new Object[]{i_field, obj, Integer.valueOf(10)},
new Object[]{c_field, obj, Character.valueOf('c')},
new Object[]{b_field, obj, Byte.valueOf((byte)1)},
new Object[]{s_field, obj, Short.valueOf((short)2)},
new Object[]{l_field, obj, Long.valueOf(1000)},
new Object[]{d_field, obj, Double.valueOf(1.2)},
new Object[]{f_field, obj, Float.valueOf(2.5f)},
new Object[]{z_field, obj, Boolean.valueOf(true)},
new Object[]{o_field, obj, "good-value"},
new Object[]{override_i_field, obj, Integer.valueOf(10)},
new Object[]{override_c_field, obj, Character.valueOf('c')},
new Object[]{override_b_field, obj, Byte.valueOf((byte)1)},
new Object[]{override_s_field, obj, Short.valueOf((short)2)},
new Object[]{override_l_field, obj, Long.valueOf(1000)},
new Object[]{override_d_field, obj, Double.valueOf(1.2)},
new Object[]{override_f_field, obj, Float.valueOf(2.5f)},
new Object[]{override_z_field, obj, Boolean.valueOf(true)},
new Object[]{override_o_field, obj, "good-value"},
// instance final fields with setAccessible(true)
new Object[]{override_fi_field, obj, Integer.valueOf(10)},
new Object[]{override_fc_field, obj, Character.valueOf('c')},
new Object[]{override_fb_field, obj, Byte.valueOf((byte)1)},
new Object[]{override_fs_field, obj, Short.valueOf((short)2)},
new Object[]{override_fl_field, obj, Long.valueOf(1000)},
new Object[]{override_fd_field, obj, Double.valueOf(1.2)},
new Object[]{override_ff_field, obj, Float.valueOf(2.5f)},
new Object[]{override_fz_field, obj, Boolean.valueOf(true)},
new Object[]{override_fo_field, obj, "good-value"},
// static fields with and without setAccessible(true)
new Object[]{si_field, null, Integer.valueOf(10)},
new Object[]{sc_field, null, Character.valueOf('c')},
new Object[]{sb_field, null, Byte.valueOf((byte)1)},
new Object[]{ss_field, null, Short.valueOf((short)2)},
new Object[]{sl_field, null, Long.valueOf(1000)},
new Object[]{sd_field, null, Double.valueOf(1.2)},
new Object[]{sf_field, null, Float.valueOf(2.5f)},
new Object[]{sz_field, null, Boolean.valueOf(true)},
new Object[]{so_field, null, "good-value"},
new Object[]{override_si_field, null, Integer.valueOf(10)},
new Object[]{override_sc_field, null, Character.valueOf('c')},
new Object[]{override_sb_field, null, Byte.valueOf((byte)1)},
new Object[]{override_ss_field, null, Short.valueOf((short)2)},
new Object[]{override_sl_field, null, Long.valueOf(1000)},
new Object[]{override_sd_field, null, Double.valueOf(1.2)},
new Object[]{override_sf_field, null, Float.valueOf(2.5f)},
new Object[]{override_sz_field, null, Boolean.valueOf(true)},
new Object[]{override_so_field, null, "good-value"},
};
}
/*
* Test Field::set with a good and bad value.
* Test setting to null if the field type is primitive.
*
* IllegalArgumentException is thrown if the value is of a bad type or null.
* NullPointerException is thrown if the receiver of an instance field is null.
* The receiver is checked
*/
@Test(dataProvider = "writeableFields")
public void testSetValue(Field f, Object obj, Object value) throws IllegalAccessException {
f.set(obj, value);
Class<?> fType = f.getType();
if (fType.isPrimitive()) {
switch (fType.descriptorString()) {
case "B" -> f.setByte(obj, ((Byte) value).byteValue());
case "C" -> f.setChar(obj, ((Character) value).charValue());
case "D" -> f.setDouble(obj, ((Double) value).doubleValue());
case "F" -> f.setFloat(obj, ((Float) value).floatValue());
case "I" -> f.setInt(obj, ((Integer) value).intValue());
case "J" -> f.setLong(obj, ((Long) value).longValue());
case "S" -> f.setShort(obj, ((Short) value).shortValue());
case "Z" -> f.setBoolean(obj, ((Boolean) value).booleanValue());
}
// test null value only if it's primitive type
try {
f.set(obj, null);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
Object badValue = new NegativeTest();
try {
f.set(obj, badValue);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
@DataProvider(name = "readOnlyFinalFields")
private Object[][] readOnlyFinalFields() {
Object obj = INSTANCE;
return new Object[][]{
// instance final fields
new Object[]{fi_field, obj, Integer.valueOf(10)},
new Object[]{fc_field, obj, Character.valueOf('c')},
new Object[]{fb_field, obj, Byte.valueOf((byte)1)},
new Object[]{fs_field, obj, Short.valueOf((short)2)},
new Object[]{fl_field, obj, Long.valueOf(1000)},
new Object[]{fd_field, obj, Double.valueOf(1.2)},
new Object[]{ff_field, obj, Float.valueOf(2.5f)},
new Object[]{fz_field, obj, Boolean.valueOf(true)},
new Object[]{fo_field, obj, "good-value"},
// static final fields
new Object[]{sfi_field, null, Integer.valueOf(10)},
new Object[]{sfc_field, null, Character.valueOf('c')},
new Object[]{sfb_field, null, Byte.valueOf((byte)1)},
new Object[]{sfs_field, null, Short.valueOf((short)2)},
new Object[]{sfl_field, null, Long.valueOf(1000)},
new Object[]{sfd_field, null, Double.valueOf(1.2)},
new Object[]{sff_field, null, Float.valueOf(2.5f)},
new Object[]{sfz_field, null, Boolean.valueOf(true)},
new Object[]{sfo_field, null, "good-value"},
new Object[]{override_sfi_field, null, Integer.valueOf(10)},
new Object[]{override_sfc_field, null, Character.valueOf('c')},
new Object[]{override_sfb_field, null, Byte.valueOf((byte)1)},
new Object[]{override_sfs_field, null, Short.valueOf((short)2)},
new Object[]{override_sfl_field, null, Long.valueOf(1000)},
new Object[]{override_sfd_field, null, Double.valueOf(1.2)},
new Object[]{override_sff_field, null, Float.valueOf(2.5f)},
new Object[]{override_sfz_field, null, Boolean.valueOf(true)},
new Object[]{override_sfo_field, null, "good-value"},
};
}
/*
* Test Field::set on a read-only final field.
* IllegalAccessException is thrown regardless of whether the value
* is of a bad type or not.
*/
@Test(dataProvider = "readOnlyFinalFields")
public void testSetValueOnFinalField(Field f, Object obj, Object value) {
assertTrue(Modifier.isFinal(f.getModifiers()));
try {
f.set(obj, value);
fail("expected IllegalAccessException");
} catch (IllegalAccessException e) {
// expected
}
Class<?> fType = f.getType();
if (fType.isPrimitive()) {
try {
switch (fType.descriptorString()) {
case "B" -> f.setByte(obj, ((Byte)value).byteValue());
case "C" -> f.setChar(obj, ((Character)value).charValue());
case "D" -> f.setDouble(obj, ((Double)value).doubleValue());
case "F" -> f.setFloat(obj, ((Float)value).floatValue());
case "I" -> f.setInt(obj, ((Integer)value).intValue());
case "J" -> f.setLong(obj, ((Long)value).longValue());
case "S" -> f.setShort(obj, ((Short)value).shortValue());
case "Z" -> f.setBoolean(obj, ((Boolean)value).booleanValue());
}
fail("expected IllegalAccessException");
} catch (IllegalAccessException e) {
// expected
}
// test null value only if it's primitive type
try {
f.set(obj, null);
fail("expected IllegalAccessException");
} catch (IllegalAccessException e) {
// expected
}
}
Object badValue = new NegativeTest();
try {
f.set(obj, badValue);
fail("expected IllegalAccessException");
} catch (IllegalAccessException e) {
// expected
}
}
@DataProvider(name = "finalInstanceFields")
private Object[][] finalInstanceFields() {
return new Object[][]{
new Object[]{fi_field, Integer.valueOf(10)},
new Object[]{fc_field, Character.valueOf('c')},
new Object[]{fb_field, Byte.valueOf((byte) 1)},
new Object[]{fs_field, Short.valueOf((short) 2)},
new Object[]{fl_field, Long.valueOf(1000)},
new Object[]{fd_field, Double.valueOf(1.2)},
new Object[]{ff_field, Float.valueOf(2.5f)},
new Object[]{fz_field, Boolean.valueOf(true)},
new Object[]{fo_field, "good-value"},
};
}
/*
* Test Field::set on a final instance field with either a bad receiver
* or null. IllegalArgumentException is thrown if the receiver is of
* a bad type. NullPointerException is thrown if the receiver is null.
* The receiver is checked before the access check is performed and
* also before the value is checked.
*/
@Test(dataProvider = "finalInstanceFields")
public void testReceiverOnFinalField(Field f, Object value) {
assertTrue(Modifier.isFinal(f.getModifiers()));
Object badReceiver = new NegativeTest();
// set the field with a bad receiver with a good value
try {
f.set(badReceiver, value);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected IllegalArgumentException but got: " + e.getMessage(), e);
}
// set the field with a bad receiver with a bad value
Object badValue = new NegativeTest();
try {
f.set(badReceiver, badValue);
fail("expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected IllegalArgumentException but got: " + e.getMessage(), e);
}
// set the field with a null receiver with a good value
try {
f.set(null, value);
fail("expected NullPointerException");
} catch (NullPointerException e) {
// expected
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected NullPointerException but got: " + e.getMessage(), e);
}
// set the field with a null receiver with a bad value
try {
f.set(null, badValue);
fail("expected NullPointerException");
} catch (NullPointerException e) {
// expected
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected NullPointerException but got: " + e.getMessage(), e);
}
Class<?> fType = f.getType();
if (fType.isPrimitive()) {
// test bad receiver
try {
switch (fType.descriptorString()) {
case "B" -> f.setByte(badReceiver, ((Byte) value).byteValue());
case "C" -> f.setChar(badReceiver, ((Character) value).charValue());
case "D" -> f.setDouble(badReceiver, ((Double) value).doubleValue());
case "F" -> f.setFloat(badReceiver, ((Float) value).floatValue());
case "I" -> f.setInt(badReceiver, ((Integer) value).intValue());
case "J" -> f.setLong(badReceiver, ((Long) value).longValue());
case "S" -> f.setShort(badReceiver, ((Short) value).shortValue());
case "Z" -> f.setBoolean(badReceiver, ((Boolean) value).booleanValue());
}
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected IllegalArgumentException but got: " + e.getMessage(), e);
}
// test null receiver
try {
switch (fType.descriptorString()) {
case "B" -> f.setByte(null, ((Byte) value).byteValue());
case "C" -> f.setChar(null, ((Character) value).charValue());
case "D" -> f.setDouble(null, ((Double) value).doubleValue());
case "F" -> f.setFloat(null, ((Float) value).floatValue());
case "I" -> f.setInt(null, ((Integer) value).intValue());
case "J" -> f.setLong(null, ((Long) value).longValue());
case "S" -> f.setShort(null, ((Short) value).shortValue());
case "Z" -> f.setBoolean(null, ((Boolean) value).booleanValue());
}
} catch (NullPointerException e) {
// expected
} catch (IllegalAccessException e) {
throw new RuntimeException("Expected NullPointerException but got: " + e.getMessage(), e);
}
}
}
}
|
