From 0ad81fbd161edbc8479e5af5c0f8d6098f6c72d1 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Thu, 22 Jan 2026 11:04:09 +0000 Subject: [PATCH 001/105] 8375541: G1: Race in G1BarrierSet::write_ref_field_post() Reviewed-by: iwalulya, sjohanss, shade --- src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp b/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp index ee2c1450d9b..794e5db0634 100644 --- a/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp +++ b/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp @@ -70,7 +70,11 @@ inline void G1BarrierSet::write_ref_field_pre(T* field) { template inline void G1BarrierSet::write_ref_field_post(T* field) { - volatile CardValue* byte = _card_table->byte_for(field); + // Make sure that the card table reference is read only once. Otherwise the compiler + // might reload that value in the two accesses below, that could cause writes to + // the wrong card table. + CardTable* card_table = AtomicAccess::load(&_card_table); + CardValue* byte = card_table->byte_for(field); if (*byte == G1CardTable::clean_card_val()) { *byte = G1CardTable::dirty_card_val(); } From 66e950e9b6414617952d22200831be5b0cafee85 Mon Sep 17 00:00:00 2001 From: Ivan Walulya Date: Thu, 22 Jan 2026 11:07:42 +0000 Subject: [PATCH 002/105] 8340470: G1: Adopt PartialArrayState to consolidate marking stack in Full GC Co-authored-by: Stefan Johansson Reviewed-by: sjohanss, tschatzl --- src/hotspot/share/gc/g1/g1FullCollector.cpp | 27 +++-- src/hotspot/share/gc/g1/g1FullCollector.hpp | 9 +- src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp | 9 +- src/hotspot/share/gc/g1/g1FullGCMarker.cpp | 46 ++++++--- src/hotspot/share/gc/g1/g1FullGCMarker.hpp | 47 ++++----- .../share/gc/g1/g1FullGCMarker.inline.hpp | 98 ++++++------------- .../share/gc/g1/g1FullGCOopClosures.cpp | 2 +- .../share/gc/g1/g1FullGCOopClosures.hpp | 4 +- 8 files changed, 110 insertions(+), 132 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1FullCollector.cpp b/src/hotspot/share/gc/g1/g1FullCollector.cpp index 5ca5dcef001..7395df01760 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.cpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -116,8 +116,8 @@ G1FullCollector::G1FullCollector(G1CollectedHeap* heap, _num_workers(calc_active_workers()), _has_compaction_targets(false), _has_humongous(false), - _oop_queue_set(_num_workers), - _array_queue_set(_num_workers), + _marking_task_queues(_num_workers), + _partial_array_state_manager(nullptr), _preserved_marks_set(true), _serial_compaction_point(this, nullptr), _humongous_compaction_point(this, nullptr), @@ -140,23 +140,31 @@ G1FullCollector::G1FullCollector(G1CollectedHeap* heap, _compaction_tops[j] = nullptr; } + _partial_array_state_manager = new PartialArrayStateManager(_num_workers); + for (uint i = 0; i < _num_workers; i++) { _markers[i] = new G1FullGCMarker(this, i, _live_stats); _compaction_points[i] = new G1FullGCCompactionPoint(this, _preserved_marks_set.get(i)); - _oop_queue_set.register_queue(i, marker(i)->oop_stack()); - _array_queue_set.register_queue(i, marker(i)->objarray_stack()); + _marking_task_queues.register_queue(i, marker(i)->task_queue()); } + _serial_compaction_point.set_preserved_stack(_preserved_marks_set.get(0)); _humongous_compaction_point.set_preserved_stack(_preserved_marks_set.get(0)); _region_attr_table.initialize(heap->reserved(), G1HeapRegion::GrainBytes); } +PartialArrayStateManager* G1FullCollector::partial_array_state_manager() const { + return _partial_array_state_manager; +} + G1FullCollector::~G1FullCollector() { for (uint i = 0; i < _num_workers; i++) { delete _markers[i]; delete _compaction_points[i]; } + delete _partial_array_state_manager; + FREE_C_HEAP_ARRAY(G1FullGCMarker*, _markers); FREE_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _compaction_points); FREE_C_HEAP_ARRAY(HeapWord*, _compaction_tops); @@ -279,8 +287,8 @@ public: uint index = (_tm == RefProcThreadModel::Single) ? 0 : worker_id; G1FullKeepAliveClosure keep_alive(_collector.marker(index)); BarrierEnqueueDiscoveredFieldClosure enqueue; - G1FollowStackClosure* complete_gc = _collector.marker(index)->stack_closure(); - _rp_task->rp_work(worker_id, &is_alive, &keep_alive, &enqueue, complete_gc); + G1MarkStackClosure* complete_marking = _collector.marker(index)->stack_closure(); + _rp_task->rp_work(worker_id, &is_alive, &keep_alive, &enqueue, complete_marking); } }; @@ -302,7 +310,7 @@ void G1FullCollector::phase1_mark_live_objects() { const ReferenceProcessorStats& stats = reference_processor()->process_discovered_references(task, _heap->workers(), pt); scope()->tracer()->report_gc_reference_stats(stats); pt.print_all_references(); - assert(marker(0)->oop_stack()->is_empty(), "Should be no oops on the stack"); + assert(marker(0)->task_queue()->is_empty(), "Should be no oops on the stack"); } { @@ -328,8 +336,7 @@ void G1FullCollector::phase1_mark_live_objects() { scope()->tracer()->report_object_count_after_gc(&_is_alive, _heap->workers()); } #if TASKQUEUE_STATS - oop_queue_set()->print_and_reset_taskqueue_stats("Oop Queue"); - array_queue_set()->print_and_reset_taskqueue_stats("ObjArrayOop Queue"); + marking_task_queues()->print_and_reset_taskqueue_stats("Marking Task Queue"); #endif } diff --git a/src/hotspot/share/gc/g1/g1FullCollector.hpp b/src/hotspot/share/gc/g1/g1FullCollector.hpp index 1fb3af17032..28ecffad944 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.hpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.hpp @@ -79,8 +79,8 @@ class G1FullCollector : StackObj { bool _has_humongous; G1FullGCMarker** _markers; G1FullGCCompactionPoint** _compaction_points; - OopQueueSet _oop_queue_set; - ObjArrayTaskQueueSet _array_queue_set; + G1MarkTasksQueueSet _marking_task_queues; + PartialArrayStateManager* _partial_array_state_manager; PreservedMarksSet _preserved_marks_set; G1FullGCCompactionPoint _serial_compaction_point; G1FullGCCompactionPoint _humongous_compaction_point; @@ -113,8 +113,7 @@ public: uint workers() { return _num_workers; } G1FullGCMarker* marker(uint id) { return _markers[id]; } G1FullGCCompactionPoint* compaction_point(uint id) { return _compaction_points[id]; } - OopQueueSet* oop_queue_set() { return &_oop_queue_set; } - ObjArrayTaskQueueSet* array_queue_set() { return &_array_queue_set; } + G1MarkTasksQueueSet* marking_task_queues() { return &_marking_task_queues; } PreservedMarksSet* preserved_mark_set() { return &_preserved_marks_set; } G1FullGCCompactionPoint* serial_compaction_point() { return &_serial_compaction_point; } G1FullGCCompactionPoint* humongous_compaction_point() { return &_humongous_compaction_point; } @@ -125,6 +124,8 @@ public: return _live_stats[region_index].live_words(); } + PartialArrayStateManager* partial_array_state_manager() const; + void before_marking_update_attribute_table(G1HeapRegion* hr); inline bool is_compacting(oop obj) const; diff --git a/src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp b/src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp index 52b0d04a500..f14e1108db8 100644 --- a/src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp +++ b/src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -34,7 +34,7 @@ G1FullGCMarkTask::G1FullGCMarkTask(G1FullCollector* collector) : G1FullGCTask("G1 Parallel Marking Task", collector), _root_processor(G1CollectedHeap::heap(), collector->workers()), - _terminator(collector->workers(), collector->array_queue_set()) { + _terminator(collector->workers(), collector->marking_task_queues()) { } void G1FullGCMarkTask::work(uint worker_id) { @@ -54,10 +54,9 @@ void G1FullGCMarkTask::work(uint worker_id) { } // Mark stack is populated, now process and drain it. - marker->complete_marking(collector()->oop_queue_set(), collector()->array_queue_set(), &_terminator); + marker->complete_marking(collector()->marking_task_queues(), &_terminator); // This is the point where the entire marking should have completed. - assert(marker->oop_stack()->is_empty(), "Marking should have completed"); - assert(marker->objarray_stack()->is_empty(), "Array marking should have completed"); + assert(marker->task_queue()->is_empty(), "Marking should have completed"); log_task("Marking task", worker_id, start); } diff --git a/src/hotspot/share/gc/g1/g1FullGCMarker.cpp b/src/hotspot/share/gc/g1/g1FullGCMarker.cpp index aa8f12a2d1b..2b0b78ac1ce 100644 --- a/src/hotspot/share/gc/g1/g1FullGCMarker.cpp +++ b/src/hotspot/share/gc/g1/g1FullGCMarker.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -25,6 +25,8 @@ #include "classfile/classLoaderData.hpp" #include "classfile/classLoaderDataGraph.hpp" #include "gc/g1/g1FullGCMarker.inline.hpp" +#include "gc/shared/partialArraySplitter.inline.hpp" +#include "gc/shared/partialArrayState.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/taskTerminator.hpp" #include "gc/shared/verifyOption.hpp" @@ -36,8 +38,8 @@ G1FullGCMarker::G1FullGCMarker(G1FullCollector* collector, _collector(collector), _worker_id(worker_id), _bitmap(collector->mark_bitmap()), - _oop_stack(), - _objarray_stack(), + _task_queue(), + _partial_array_splitter(collector->partial_array_state_manager(), collector->workers(), ObjArrayMarkingStride), _mark_closure(worker_id, this, ClassLoaderData::_claim_stw_fullgc_mark, G1CollectedHeap::heap()->ref_processor_stw()), _stack_closure(this), _cld_closure(mark_closure(), ClassLoaderData::_claim_stw_fullgc_mark), @@ -47,24 +49,36 @@ G1FullGCMarker::G1FullGCMarker(G1FullCollector* collector, } G1FullGCMarker::~G1FullGCMarker() { - assert(is_empty(), "Must be empty at this point"); + assert(is_task_queue_empty(), "Must be empty at this point"); } -void G1FullGCMarker::complete_marking(OopQueueSet* oop_stacks, - ObjArrayTaskQueueSet* array_stacks, +void G1FullGCMarker::process_partial_array(PartialArrayState* state, bool stolen) { + // Access state before release by claim(). + objArrayOop obj_array = objArrayOop(state->source()); + PartialArraySplitter::Claim claim = + _partial_array_splitter.claim(state, task_queue(), stolen); + process_array_chunk(obj_array, claim._start, claim._end); +} + +void G1FullGCMarker::start_partial_array_processing(objArrayOop obj) { + mark_closure()->do_klass(obj->klass()); + // Don't push empty arrays to avoid unnecessary work. + size_t array_length = obj->length(); + if (array_length > 0) { + size_t initial_chunk_size = _partial_array_splitter.start(task_queue(), obj, nullptr, array_length); + process_array_chunk(obj, 0, initial_chunk_size); + } +} + +void G1FullGCMarker::complete_marking(G1ScannerTasksQueueSet* task_queues, TaskTerminator* terminator) { do { - follow_marking_stacks(); - ObjArrayTask steal_array; - if (array_stacks->steal(_worker_id, steal_array)) { - follow_array_chunk(objArrayOop(steal_array.obj()), steal_array.index()); - } else { - oop steal_oop; - if (oop_stacks->steal(_worker_id, steal_oop)) { - follow_object(steal_oop); - } + process_marking_stacks(); + ScannerTask stolen_task; + if (task_queues->steal(_worker_id, stolen_task)) { + dispatch_task(stolen_task, true); } - } while (!is_empty() || !terminator->offer_termination()); + } while (!is_task_queue_empty() || !terminator->offer_termination()); } void G1FullGCMarker::flush_mark_stats_cache() { diff --git a/src/hotspot/share/gc/g1/g1FullGCMarker.hpp b/src/hotspot/share/gc/g1/g1FullGCMarker.hpp index b1b750eae90..5973cc841c5 100644 --- a/src/hotspot/share/gc/g1/g1FullGCMarker.hpp +++ b/src/hotspot/share/gc/g1/g1FullGCMarker.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -28,6 +28,8 @@ #include "gc/g1/g1FullGCOopClosures.hpp" #include "gc/g1/g1OopClosures.hpp" #include "gc/g1/g1RegionMarkStatsCache.hpp" +#include "gc/shared/partialArraySplitter.hpp" +#include "gc/shared/partialArrayState.hpp" #include "gc/shared/stringdedup/stringDedup.hpp" #include "gc/shared/taskqueue.hpp" #include "memory/iterator.hpp" @@ -38,16 +40,15 @@ #include "utilities/growableArray.hpp" #include "utilities/stack.hpp" -typedef OverflowTaskQueue OopQueue; -typedef OverflowTaskQueue ObjArrayTaskQueue; -typedef GenericTaskQueueSet OopQueueSet; -typedef GenericTaskQueueSet ObjArrayTaskQueueSet; class G1CMBitMap; class G1FullCollector; class TaskTerminator; +typedef OverflowTaskQueue G1MarkTasksQueue; +typedef GenericTaskQueueSet G1MarkTasksQueueSet; + class G1FullGCMarker : public CHeapObj { G1FullCollector* _collector; @@ -56,56 +57,50 @@ class G1FullGCMarker : public CHeapObj { G1CMBitMap* _bitmap; // Mark stack - OopQueue _oop_stack; - ObjArrayTaskQueue _objarray_stack; + G1MarkTasksQueue _task_queue; + PartialArraySplitter _partial_array_splitter; // Marking closures G1MarkAndPushClosure _mark_closure; - G1FollowStackClosure _stack_closure; + G1MarkStackClosure _stack_closure; CLDToOopClosure _cld_closure; StringDedup::Requests _string_dedup_requests; G1RegionMarkStatsCache _mark_stats_cache; - inline bool is_empty(); - inline void push_objarray(oop obj, size_t index); + inline bool is_task_queue_empty(); inline bool mark_object(oop obj); // Marking helpers - inline void follow_object(oop obj); - inline void follow_array(objArrayOop array); - inline void follow_array_chunk(objArrayOop array, int index); + inline void process_array_chunk(objArrayOop obj, size_t start, size_t end); + inline void dispatch_task(const ScannerTask& task, bool stolen); + // Start processing the given objArrayOop by first pushing its continuations and + // then scanning the first chunk. + void start_partial_array_processing(objArrayOop obj); + // Process the given continuation. + void process_partial_array(PartialArrayState* state, bool stolen); inline void publish_and_drain_oop_tasks(); - // Try to publish all contents from the objArray task queue overflow stack to - // the shared objArray stack. - // Returns true and a valid task if there has not been enough space in the shared - // objArray stack, otherwise returns false and the task is invalid. - inline bool publish_or_pop_objarray_tasks(ObjArrayTask& task); - public: G1FullGCMarker(G1FullCollector* collector, uint worker_id, G1RegionMarkStats* mark_stats); ~G1FullGCMarker(); - // Stack getters - OopQueue* oop_stack() { return &_oop_stack; } - ObjArrayTaskQueue* objarray_stack() { return &_objarray_stack; } + G1MarkTasksQueue* task_queue() { return &_task_queue; } // Marking entry points template inline void mark_and_push(T* p); - inline void follow_marking_stacks(); - void complete_marking(OopQueueSet* oop_stacks, - ObjArrayTaskQueueSet* array_stacks, + inline void process_marking_stacks(); + void complete_marking(G1MarkTasksQueueSet* task_queues, TaskTerminator* terminator); // Closure getters CLDToOopClosure* cld_closure() { return &_cld_closure; } G1MarkAndPushClosure* mark_closure() { return &_mark_closure; } - G1FollowStackClosure* stack_closure() { return &_stack_closure; } + G1MarkStackClosure* stack_closure() { return &_stack_closure; } // Flush live bytes to regions void flush_mark_stats_cache(); diff --git a/src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp b/src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp index 398ef046bf5..a6f45abe005 100644 --- a/src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp +++ b/src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -42,6 +42,7 @@ #include "oops/access.inline.hpp" #include "oops/compressedOops.inline.hpp" #include "oops/oop.inline.hpp" +#include "utilities/checkedCast.hpp" #include "utilities/debug.hpp" inline bool G1FullGCMarker::mark_object(oop obj) { @@ -71,94 +72,55 @@ template inline void G1FullGCMarker::mark_and_push(T* p) { if (!CompressedOops::is_null(heap_oop)) { oop obj = CompressedOops::decode_not_null(heap_oop); if (mark_object(obj)) { - _oop_stack.push(obj); + _task_queue.push(ScannerTask(obj)); } assert(_bitmap->is_marked(obj), "Must be marked"); } } -inline bool G1FullGCMarker::is_empty() { - return _oop_stack.is_empty() && _objarray_stack.is_empty(); +inline bool G1FullGCMarker::is_task_queue_empty() { + return _task_queue.is_empty(); } -inline void G1FullGCMarker::push_objarray(oop obj, size_t index) { - ObjArrayTask task(obj, index); - assert(task.is_valid(), "bad ObjArrayTask"); - _objarray_stack.push(task); +inline void G1FullGCMarker::process_array_chunk(objArrayOop obj, size_t start, size_t end) { + obj->oop_iterate_elements_range(mark_closure(), + checked_cast(start), + checked_cast(end)); } -inline void G1FullGCMarker::follow_array(objArrayOop array) { - mark_closure()->do_klass(array->klass()); - // Don't push empty arrays to avoid unnecessary work. - if (array->length() > 0) { - push_objarray(array, 0); - } -} - -void G1FullGCMarker::follow_array_chunk(objArrayOop array, int index) { - const int len = array->length(); - const int beg_index = index; - assert(beg_index < len || len == 0, "index too large"); - - const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride); - const int end_index = beg_index + stride; - - // Push the continuation first to allow more efficient work stealing. - if (end_index < len) { - push_objarray(array, end_index); - } - - array->oop_iterate_elements_range(mark_closure(), beg_index, end_index); -} - -inline void G1FullGCMarker::follow_object(oop obj) { - assert(_bitmap->is_marked(obj), "should be marked"); - if (obj->is_objArray()) { - // Handle object arrays explicitly to allow them to - // be split into chunks if needed. - follow_array((objArrayOop)obj); +inline void G1FullGCMarker::dispatch_task(const ScannerTask& task, bool stolen) { + if (task.is_partial_array_state()) { + assert(_bitmap->is_marked(task.to_partial_array_state()->source()), "should be marked"); + process_partial_array(task.to_partial_array_state(), stolen); } else { - obj->oop_iterate(mark_closure()); + oop obj = task.to_oop(); + assert(_bitmap->is_marked(obj), "should be marked"); + if (obj->is_objArray()) { + // Handle object arrays explicitly to allow them to + // be split into chunks if needed. + start_partial_array_processing((objArrayOop)obj); + } else { + obj->oop_iterate(mark_closure()); + } } } inline void G1FullGCMarker::publish_and_drain_oop_tasks() { - oop obj; - while (_oop_stack.pop_overflow(obj)) { - if (!_oop_stack.try_push_to_taskqueue(obj)) { - assert(_bitmap->is_marked(obj), "must be marked"); - follow_object(obj); + ScannerTask task; + while (_task_queue.pop_overflow(task)) { + if (!_task_queue.try_push_to_taskqueue(task)) { + dispatch_task(task, false); } } - while (_oop_stack.pop_local(obj)) { - assert(_bitmap->is_marked(obj), "must be marked"); - follow_object(obj); + while (_task_queue.pop_local(task)) { + dispatch_task(task, false); } } -inline bool G1FullGCMarker::publish_or_pop_objarray_tasks(ObjArrayTask& task) { - // It is desirable to move as much as possible work from the overflow queue to - // the shared queue as quickly as possible. - while (_objarray_stack.pop_overflow(task)) { - if (!_objarray_stack.try_push_to_taskqueue(task)) { - return true; - } - } - return false; -} - -void G1FullGCMarker::follow_marking_stacks() { +void G1FullGCMarker::process_marking_stacks() { do { - // First, drain regular oop stack. publish_and_drain_oop_tasks(); - - // Then process ObjArrays one at a time to avoid marking stack bloat. - ObjArrayTask task; - if (publish_or_pop_objarray_tasks(task) || - _objarray_stack.pop_local(task)) { - follow_array_chunk(objArrayOop(task.obj()), task.index()); - } - } while (!is_empty()); + } while (!is_task_queue_empty()); } #endif // SHARE_GC_G1_G1FULLGCMARKER_INLINE_HPP diff --git a/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp b/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp index d9cf64a3655..273508ea9e3 100644 --- a/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp +++ b/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp @@ -35,7 +35,7 @@ G1IsAliveClosure::G1IsAliveClosure(G1FullCollector* collector) : G1IsAliveClosure(collector, collector->mark_bitmap()) { } -void G1FollowStackClosure::do_void() { _marker->follow_marking_stacks(); } +void G1MarkStackClosure::do_void() { _marker->process_marking_stacks(); } void G1FullKeepAliveClosure::do_oop(oop* p) { do_oop_work(p); } void G1FullKeepAliveClosure::do_oop(narrowOop* p) { do_oop_work(p); } diff --git a/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp b/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp index 388f8032de4..08ed5f982e1 100644 --- a/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp +++ b/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp @@ -86,11 +86,11 @@ public: virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; } }; -class G1FollowStackClosure: public VoidClosure { +class G1MarkStackClosure: public VoidClosure { G1FullGCMarker* _marker; public: - G1FollowStackClosure(G1FullGCMarker* marker) : _marker(marker) {} + G1MarkStackClosure(G1FullGCMarker* marker) : _marker(marker) {} virtual void do_void(); }; From 5e0ed3f408b6afd7496e0e0da207f7e372b0d446 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Thu, 22 Jan 2026 11:51:37 +0000 Subject: [PATCH 003/105] 8375982: G1: Convert G1YoungCollector helper classes to use Atomic Reviewed-by: kbarrett, shade --- src/hotspot/share/gc/g1/g1YoungCollector.cpp | 19 ++++++++++--------- .../gc/g1/g1YoungGCPostEvacuateTasks.cpp | 7 ++++--- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1YoungCollector.cpp b/src/hotspot/share/gc/g1/g1YoungCollector.cpp index fa5c617f1db..36cc44a8b7c 100644 --- a/src/hotspot/share/gc/g1/g1YoungCollector.cpp +++ b/src/hotspot/share/gc/g1/g1YoungCollector.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -58,6 +58,7 @@ #include "gc/shared/workerThread.hpp" #include "jfr/jfrEvents.hpp" #include "memory/resourceArea.hpp" +#include "runtime/atomic.hpp" #include "runtime/threads.hpp" #include "utilities/ticks.hpp" @@ -459,8 +460,8 @@ class G1PrepareEvacuationTask : public WorkerTask { G1CollectedHeap* _g1h; G1HeapRegionClaimer _claimer; - volatile uint _humongous_total; - volatile uint _humongous_candidates; + Atomic _humongous_total; + Atomic _humongous_candidates; G1MonotonicArenaMemoryStats _all_card_set_stats; @@ -481,19 +482,19 @@ public: } void add_humongous_candidates(uint candidates) { - AtomicAccess::add(&_humongous_candidates, candidates); + _humongous_candidates.add_then_fetch(candidates); } void add_humongous_total(uint total) { - AtomicAccess::add(&_humongous_total, total); + _humongous_total.add_then_fetch(total); } uint humongous_candidates() { - return _humongous_candidates; + return _humongous_candidates.load_relaxed(); } uint humongous_total() { - return _humongous_total; + return _humongous_total.load_relaxed(); } const G1MonotonicArenaMemoryStats all_card_set_stats() const { @@ -698,7 +699,7 @@ protected: virtual void evacuate_live_objects(G1ParScanThreadState* pss, uint worker_id) = 0; private: - volatile bool _pinned_regions_recorded; + Atomic _pinned_regions_recorded; public: G1EvacuateRegionsBaseTask(const char* name, @@ -722,7 +723,7 @@ public: G1ParScanThreadState* pss = _per_thread_states->state_for_worker(worker_id); pss->set_ref_discoverer(_g1h->ref_processor_stw()); - if (!AtomicAccess::cmpxchg(&_pinned_regions_recorded, false, true)) { + if (_pinned_regions_recorded.compare_set(false, true)) { record_pinned_regions(pss, worker_id); } scan_roots(pss, worker_id); diff --git a/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp b/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp index ec5d2393d8c..46d12df575c 100644 --- a/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp +++ b/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp @@ -46,6 +46,7 @@ #include "oops/access.inline.hpp" #include "oops/compressedOops.inline.hpp" #include "oops/oop.inline.hpp" +#include "runtime/atomic.hpp" #include "runtime/prefetch.inline.hpp" #include "runtime/threads.hpp" #include "runtime/threadSMR.hpp" @@ -759,7 +760,7 @@ class G1PostEvacuateCollectionSetCleanupTask2::FreeCollectionSetTask : public G1 const size_t* _surviving_young_words; uint _active_workers; G1EvacFailureRegions* _evac_failure_regions; - volatile uint _num_retained_regions; + Atomic _num_retained_regions; FreeCSetStats* worker_stats(uint worker) { return &_worker_stats[worker]; @@ -794,7 +795,7 @@ public: virtual ~FreeCollectionSetTask() { Ticks serial_time = Ticks::now(); - bool has_new_retained_regions = AtomicAccess::load(&_num_retained_regions) != 0; + bool has_new_retained_regions = _num_retained_regions.load_relaxed() != 0; if (has_new_retained_regions) { G1CollectionSetCandidates* candidates = _g1h->collection_set()->candidates(); candidates->sort_by_efficiency(); @@ -829,7 +830,7 @@ public: // Report per-region type timings. cl.report_timing(); - AtomicAccess::add(&_num_retained_regions, cl.num_retained_regions(), memory_order_relaxed); + _num_retained_regions.add_then_fetch(cl.num_retained_regions(), memory_order_relaxed); } }; From 0d1d4d07b9fa2368f471f30e176d446698500115 Mon Sep 17 00:00:00 2001 From: Roland Westrelin Date: Thu, 22 Jan 2026 12:09:11 +0000 Subject: [PATCH 004/105] 8374725: C2: assert(x_ctrl == get_late_ctrl_with_anti_dep(x->as_Load(), early_ctrl, x_ctrl)) failed: anti-dependences were already checked Reviewed-by: chagedorn, qamai, dfenacci --- src/hotspot/share/opto/loopopts.cpp | 10 +-- .../loopopts/TestSinkingLoadInputOfPhi.java | 63 +++++++++++++++++++ 2 files changed, 68 insertions(+), 5 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/loopopts/TestSinkingLoadInputOfPhi.java diff --git a/src/hotspot/share/opto/loopopts.cpp b/src/hotspot/share/opto/loopopts.cpp index 9e3d4681e7c..1855263539b 100644 --- a/src/hotspot/share/opto/loopopts.cpp +++ b/src/hotspot/share/opto/loopopts.cpp @@ -1922,11 +1922,6 @@ bool PhaseIdealLoop::ctrl_of_all_uses_out_of_loop(const Node* n, Node* n_ctrl, I if (u->is_Opaque1()) { return false; // Found loop limit, bugfix for 4677003 } - // We can't reuse tags in PhaseIdealLoop::dom_lca_for_get_late_ctrl_internal() so make sure calls to - // get_late_ctrl_with_anti_dep() use their own tag - _dom_lca_tags_round++; - assert(_dom_lca_tags_round != 0, "shouldn't wrap around"); - if (u->is_Phi()) { for (uint j = 1; j < u->req(); ++j) { if (u->in(j) == n && !ctrl_of_use_out_of_loop(n, n_ctrl, n_loop, u->in(0)->in(j))) { @@ -1960,6 +1955,11 @@ bool PhaseIdealLoop::would_sink_below_pre_loop_exit(IdealLoopTree* n_loop, Node* bool PhaseIdealLoop::ctrl_of_use_out_of_loop(const Node* n, Node* n_ctrl, IdealLoopTree* n_loop, Node* ctrl) { if (n->is_Load()) { + // We can't reuse tags in PhaseIdealLoop::dom_lca_for_get_late_ctrl_internal() so make sure each call to + // get_late_ctrl_with_anti_dep() uses its own tag + _dom_lca_tags_round++; + assert(_dom_lca_tags_round != 0, "shouldn't wrap around"); + ctrl = get_late_ctrl_with_anti_dep(n->as_Load(), n_ctrl, ctrl); } IdealLoopTree *u_loop = get_loop(ctrl); diff --git a/test/hotspot/jtreg/compiler/loopopts/TestSinkingLoadInputOfPhi.java b/test/hotspot/jtreg/compiler/loopopts/TestSinkingLoadInputOfPhi.java new file mode 100644 index 00000000000..cd563e6caf2 --- /dev/null +++ b/test/hotspot/jtreg/compiler/loopopts/TestSinkingLoadInputOfPhi.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2026 IBM Corporation. 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 8374725 + * @summary C2: assert(x_ctrl == get_late_ctrl_with_anti_dep(x->as_Load(), early_ctrl, x_ctrl)) failed: anti-dependences were already checked + * @run main/othervm -XX:CompileCommand=compileonly,*TestSinkingLoadInputOfPhi*::* -XX:-TieredCompilation -Xcomp ${test.main.class} + * @run main ${test.main.class} + */ + +package compiler.loopopts; + +public class TestSinkingLoadInputOfPhi { + + static long lFld; + static int iFld = 55; + static int iFld2 = 10; + static void test() { + int iArr[] = new int[iFld2]; + + for (int i13 : iArr) + switch (iFld) { + case 69: + case 46: + case 65: + lFld = i13; + case 55: // taken + for (int i16 = 1; i16 < 30000; i16++) + ; + case 71: + iArr[iFld2] = 2; // OOB-access + } + } + + public static void main(String[] strArr) { + try { + test(); + } catch (ArrayIndexOutOfBoundsException e) { + // expected + } + } +} From eda15aa19c36142984edaa08850132ca6ae7a369 Mon Sep 17 00:00:00 2001 From: Weijun Wang Date: Thu, 22 Jan 2026 12:16:09 +0000 Subject: [PATCH 005/105] 8277489: Rewrite JAAS UnixLoginModule with FFM Co-authored-by: Martin Doerr Reviewed-by: mdoerr, ascarpino, erikj --- make/modules/jdk.security.auth/Lib.gmk | 17 +- src/java.base/share/classes/module-info.java | 3 +- .../security/auth/module/UnixLoginModule.java | 32 +++- .../sun/security/auth/module/UnixSystem.java | 180 ++++++++++++++++-- .../unix/native/libjaas/Unix.c | 130 ------------- .../security/auth/module/AllPlatforms.java | 23 ++- 6 files changed, 220 insertions(+), 165 deletions(-) delete mode 100644 src/jdk.security.auth/unix/native/libjaas/Unix.c diff --git a/make/modules/jdk.security.auth/Lib.gmk b/make/modules/jdk.security.auth/Lib.gmk index 9ead32dbe12..96d609f08d6 100644 --- a/make/modules/jdk.security.auth/Lib.gmk +++ b/make/modules/jdk.security.auth/Lib.gmk @@ -31,13 +31,14 @@ include LibCommon.gmk ## Build libjaas ################################################################################ -$(eval $(call SetupJdkLibrary, BUILD_LIBJAAS, \ - NAME := jaas, \ - OPTIMIZATION := LOW, \ - EXTRA_HEADER_DIRS := java.base:libjava, \ - LIBS_windows := advapi32.lib mpr.lib netapi32.lib user32.lib, \ -)) - -TARGETS += $(BUILD_LIBJAAS) +ifeq ($(call isTargetOs, windows), true) + $(eval $(call SetupJdkLibrary, BUILD_LIBJAAS, \ + NAME := jaas, \ + OPTIMIZATION := LOW, \ + EXTRA_HEADER_DIRS := java.base:libjava, \ + LIBS_windows := advapi32.lib mpr.lib netapi32.lib user32.lib, \ + )) + TARGETS += $(BUILD_LIBJAAS) +endif ################################################################################ diff --git a/src/java.base/share/classes/module-info.java b/src/java.base/share/classes/module-info.java index 70a79390828..d20f6311bca 100644 --- a/src/java.base/share/classes/module-info.java +++ b/src/java.base/share/classes/module-info.java @@ -274,7 +274,8 @@ module java.base { jdk.httpserver, jdk.jlink, jdk.jpackage, - jdk.net; + jdk.net, + jdk.security.auth; exports sun.net to java.net.http, jdk.naming.dns; diff --git a/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixLoginModule.java b/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixLoginModule.java index 785b178e296..4f6d8ca25ef 100644 --- a/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixLoginModule.java +++ b/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixLoginModule.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -26,7 +26,6 @@ package com.sun.security.auth.module; import java.util.*; -import java.io.IOException; import javax.security.auth.*; import javax.security.auth.callback.*; import javax.security.auth.login.*; @@ -34,6 +33,7 @@ import javax.security.auth.spi.*; import com.sun.security.auth.UnixPrincipal; import com.sun.security.auth.UnixNumericUserPrincipal; import com.sun.security.auth.UnixNumericGroupPrincipal; +import jdk.internal.util.OperatingSystem; /** * This {@code LoginModule} imports a user's Unix @@ -121,20 +121,34 @@ public class UnixLoginModule implements LoginModule { */ public boolean login() throws LoginException { - long[] unixGroups = null; + // Fail immediately on Windows to avoid cygwin-like functions + // being loaded, which are not supported. + if (OperatingSystem.isWindows()) { + throw new FailedLoginException + ("Failed in attempt to import " + + "the underlying system identity information" + + " on " + System.getProperty("os.name")); + } try { ss = new UnixSystem(); - } catch (UnsatisfiedLinkError ule) { + } catch (ExceptionInInitializerError | UnsatisfiedLinkError ule) { + // Errors could happen in either static blocks or the constructor, + // both have a cause. succeeded = false; - throw new FailedLoginException + var error = new FailedLoginException ("Failed in attempt to import " + "the underlying system identity information" + " on " + System.getProperty("os.name")); + if (ule.getCause() != null) { + error.initCause(ule.getCause()); + } + throw error; } userPrincipal = new UnixPrincipal(ss.getUsername()); UIDPrincipal = new UnixNumericUserPrincipal(ss.getUid()); GIDPrincipal = new UnixNumericGroupPrincipal(ss.getGid(), true); + long[] unixGroups = null; if (ss.getGroups() != null && ss.getGroups().length > 0) { unixGroups = ss.getGroups(); for (int i = 0; i < unixGroups.length; i++) { @@ -150,9 +164,11 @@ public class UnixLoginModule implements LoginModule { "succeeded importing info: "); System.out.println("\t\t\tuid = " + ss.getUid()); System.out.println("\t\t\tgid = " + ss.getGid()); - unixGroups = ss.getGroups(); - for (int i = 0; i < unixGroups.length; i++) { - System.out.println("\t\t\tsupp gid = " + unixGroups[i]); + System.out.println("\t\t\tusername = " + ss.getUsername()); + if (unixGroups != null) { + for (int i = 0; i < unixGroups.length; i++) { + System.out.println("\t\t\tsupp gid = " + unixGroups[i]); + } } } succeeded = true; diff --git a/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixSystem.java b/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixSystem.java index f3741c10404..c0e47fafc2c 100644 --- a/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixSystem.java +++ b/src/jdk.security.auth/share/classes/com/sun/security/auth/module/UnixSystem.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -25,38 +25,194 @@ package com.sun.security.auth.module; +import jdk.internal.util.Architecture; +import jdk.internal.util.OperatingSystem; + +import java.lang.foreign.AddressLayout; +import java.lang.foreign.Arena; +import java.lang.foreign.FunctionDescriptor; +import java.lang.foreign.GroupLayout; +import java.lang.foreign.Linker; +import java.lang.foreign.MemoryLayout; +import java.lang.foreign.MemorySegment; +import java.lang.foreign.StructLayout; +import java.lang.foreign.SymbolLookup; +import java.lang.foreign.ValueLayout; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.VarHandle; + +import static java.lang.foreign.MemoryLayout.PathElement.groupElement; + /** * This class implementation retrieves and makes available Unix * UID/GID/groups information for the current user. * * @since 1.4 */ +@SuppressWarnings("restricted") public class UnixSystem { - private native void getUnixInfo(); - - // Warning: the following 4 fields are used by Unix.c - - /** The current username. */ + /** + * The current username. + */ protected String username; - /** The current user ID. */ + /** + * The current user ID. + */ protected long uid; - /** The current group ID. */ + /** + * The current group ID. + */ protected long gid; - /** The current list of groups. */ + /** + * The current list of groups. + */ protected long[] groups; + private static final Linker LINKER = Linker.nativeLinker(); + private static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup() + .or(LINKER.defaultLookup()); + + private static final ValueLayout.OfByte C_CHAR + = (ValueLayout.OfByte) LINKER.canonicalLayouts().get("char"); + private static final ValueLayout.OfInt C_INT + = (ValueLayout.OfInt) LINKER.canonicalLayouts().get("int"); + private static final ValueLayout.OfLong C_LONG + = (ValueLayout.OfLong) LINKER.canonicalLayouts().get("long"); + private static final AddressLayout C_POINTER + = ((AddressLayout) LINKER.canonicalLayouts().get("void*")) + .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, C_CHAR)); + private static final ValueLayout C_SIZE_T + = (ValueLayout) LINKER.canonicalLayouts().get("size_t"); + + private static final StructLayout CAPTURE_STATE_LAYOUT + = Linker.Option.captureStateLayout(); + private static final VarHandle VH_errno = CAPTURE_STATE_LAYOUT.varHandle( + MemoryLayout.PathElement.groupElement("errno")); + + private static final MethodHandle MH_strerror + = LINKER.downcallHandle(SYMBOL_LOOKUP.findOrThrow("strerror"), + FunctionDescriptor.of(C_POINTER, C_INT)); + + private static final MethodHandle MH_getgroups + = LINKER.downcallHandle(SYMBOL_LOOKUP.findOrThrow("getgroups"), + FunctionDescriptor.of(C_INT, C_INT, C_POINTER), + Linker.Option.captureCallState("errno")); + private static final MethodHandle MH_getuid + = LINKER.downcallHandle(SYMBOL_LOOKUP.findOrThrow("getuid"), + FunctionDescriptor.of(C_INT)); + + // Some architectures require appropriate zero or sign extension to 64 bit. + // Use long directly before https://bugs.openjdk.org/browse/JDK-8336664 is resolved. + private static final boolean calling_convention_requires_int_as_long + = Architecture.isPPC64() || Architecture.isPPC64LE() || Architecture.isS390(); + + // getpwuid_r does not work on AIX, instead we use another similar function + // extern int _posix_getpwuid_r(uid_t, struct passwd *, char *, int, struct passwd **) + private static final MethodHandle MH_getpwuid_r + = LINKER.downcallHandle(SYMBOL_LOOKUP.findOrThrow( + OperatingSystem.isAix() ? "_posix_getpwuid_r" : "getpwuid_r"), + FunctionDescriptor.of(C_INT, + calling_convention_requires_int_as_long ? C_LONG : C_INT, + C_POINTER, C_POINTER, + OperatingSystem.isAix() ? C_INT : C_SIZE_T, + C_POINTER)); + + private static final GroupLayout ML_passwd = MemoryLayout.structLayout( + C_POINTER.withName("pw_name"), + C_POINTER.withName("pw_passwd"), + C_INT.withName("pw_uid"), + C_INT.withName("pw_gid"), + // Different platforms have different fields in `struct passwd`. + // While we don't need those fields here, the struct needs to be + // big enough to avoid buffer overflow when `getpwuid_r` is called. + MemoryLayout.paddingLayout(100)); + + private static final VarHandle VH_pw_uid + = ML_passwd.varHandle(groupElement("pw_uid")); + private static final VarHandle VH_pw_gid + = ML_passwd.varHandle(groupElement("pw_gid")); + private static final VarHandle VH_pw_name + = ML_passwd.varHandle(groupElement("pw_name")); + + // The buffer size for the getpwuid_r function: + // 1. sysconf(_SC_GETPW_R_SIZE_MAX) on macOS is 4096 and 1024 on Linux, + // so we choose a bigger one. + // 2. We do not call sysconf() here because even _SC_GETPW_R_SIZE_MAX + // could be different on different platforms. + // 3. We choose int instead of long because the buffer_size argument + // might be `int` or `long` and converting from `long` to `int` + // requires an explicit cast. + private static final int GETPW_R_SIZE_MAX = 4096; + /** * Instantiate a {@code UnixSystem} and load * the native library to access the underlying system information. */ - @SuppressWarnings("restricted") public UnixSystem() { - System.loadLibrary("jaas"); - getUnixInfo(); + // The FFM code has only been tested on multiple platforms + // (including macOS, Linux, AIX, etc) and might fail on other + // *nix systems. Especially, the `passwd` struct could be defined + // differently. I've checked several and an extra 100 chars at the + // end seems enough. + try (Arena scope = Arena.ofConfined()) { + MemorySegment capturedState = scope.allocate(CAPTURE_STATE_LAYOUT); + int groupnum = (int) MH_getgroups.invokeExact(capturedState, 0, MemorySegment.NULL); + if (groupnum == -1) { + throw new RuntimeException("getgroups returns " + groupnum); + } + + var gs = scope.allocate(C_INT, groupnum); + groupnum = (int) MH_getgroups.invokeExact(capturedState, groupnum, gs); + if (groupnum == -1) { + var errno = (int) VH_errno.get(capturedState, 0L); + var errMsg = (MemorySegment) MH_strerror.invokeExact(errno); + throw new RuntimeException("getgroups returns " + groupnum + + ". Reason: " + errMsg.reinterpret(Long.MAX_VALUE).getString(0)); + } + + groups = new long[groupnum]; + for (int i = 0; i < groupnum; i++) { + groups[i] = Integer.toUnsignedLong(gs.getAtIndex(C_INT, i)); + } + + var pwd = scope.allocate(ML_passwd); + var result = scope.allocate(C_POINTER); + var buffer = scope.allocate(GETPW_R_SIZE_MAX); + + long tmpUid = Integer.toUnsignedLong((int) MH_getuid.invokeExact()); + + // Do not call invokeExact because the type of buffer_size is not + // always long in the underlying system. + int out; + if (calling_convention_requires_int_as_long) { + out = (int) MH_getpwuid_r.invoke( + tmpUid, pwd, buffer, GETPW_R_SIZE_MAX, result); + } else { + out = (int) MH_getpwuid_r.invoke( + (int) tmpUid, pwd, buffer, GETPW_R_SIZE_MAX, result); + } + if (out != 0) { + // If ERANGE (Result too large) is detected in a new platform, + // consider adjusting GETPW_R_SIZE_MAX. + var err = (MemorySegment) MH_strerror.invokeExact(out); + throw new RuntimeException(err.reinterpret(Long.MAX_VALUE).getString(0)); + } else if (result.get(ValueLayout.ADDRESS, 0).equals(MemorySegment.NULL)) { + throw new RuntimeException("the requested entry is not found"); + } else { + // uid_t and gid_t were defined unsigned. + uid = Integer.toUnsignedLong((int) VH_pw_uid.get(pwd, 0L)); + gid = Integer.toUnsignedLong((int) VH_pw_gid.get(pwd, 0L)); + username = ((MemorySegment) VH_pw_name.get(pwd, 0L)).getString(0); + } + } catch (Throwable t) { + var error = new UnsatisfiedLinkError("FFM calls failed"); + error.initCause(t); + throw error; + } } /** diff --git a/src/jdk.security.auth/unix/native/libjaas/Unix.c b/src/jdk.security.auth/unix/native/libjaas/Unix.c deleted file mode 100644 index 3a93df9ffc9..00000000000 --- a/src/jdk.security.auth/unix/native/libjaas/Unix.c +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (c) 2000, 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. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * 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. - */ - -#include -#include "jni_util.h" -#include "com_sun_security_auth_module_UnixSystem.h" -#include -#include -#include -#include -#include - -#include - -/* - * Declare library specific JNI_Onload entry if static build - */ -DEF_STATIC_JNI_OnLoad - -JNIEXPORT void JNICALL -Java_com_sun_security_auth_module_UnixSystem_getUnixInfo - (JNIEnv *env, jobject obj) { - - int i; - char pwd_buf[1024]; - struct passwd *pwd = NULL; - struct passwd resbuf; - jfieldID userNameID; - jfieldID userID; - jfieldID groupID; - jfieldID supplementaryGroupID; - - jstring jstr; - jlongArray jgroups; - jlong *jgroupsAsArray; - jsize numSuppGroups; - gid_t *groups; - jclass cls; - - numSuppGroups = getgroups(0, NULL); - if (numSuppGroups == -1) { - return; - } - groups = (gid_t *)calloc(numSuppGroups, sizeof(gid_t)); - if (groups == NULL) { - jclass cls = (*env)->FindClass(env,"java/lang/OutOfMemoryError"); - if (cls != NULL) { - (*env)->ThrowNew(env, cls, NULL); - } - return; - } - - cls = (*env)->GetObjectClass(env, obj); - - supplementaryGroupID = (*env)->GetFieldID(env, cls, "groups", "[J"); - if (supplementaryGroupID == 0) { - goto cleanUpAndReturn; - } - - if (getgroups(numSuppGroups, groups) != -1) { - jgroups = (*env)->NewLongArray(env, numSuppGroups); - if (jgroups == NULL) { - goto cleanUpAndReturn; - } - jgroupsAsArray = (*env)->GetLongArrayElements(env, jgroups, 0); - if (jgroupsAsArray == NULL) { - goto cleanUpAndReturn; - } - for (i = 0; i < numSuppGroups; i++) { - jgroupsAsArray[i] = groups[i]; - } - (*env)->ReleaseLongArrayElements(env, jgroups, jgroupsAsArray, 0); - (*env)->SetObjectField(env, obj, supplementaryGroupID, jgroups); - } - - userNameID = (*env)->GetFieldID(env, cls, "username", "Ljava/lang/String;"); - if (userNameID == 0) { - goto cleanUpAndReturn; - } - - userID = (*env)->GetFieldID(env, cls, "uid", "J"); - if (userID == 0) { - goto cleanUpAndReturn; - } - - groupID = (*env)->GetFieldID(env, cls, "gid", "J"); - if (groupID == 0) { - goto cleanUpAndReturn; - } - - memset(pwd_buf, 0, sizeof(pwd_buf)); - if (getpwuid_r(getuid(), &resbuf, pwd_buf, sizeof(pwd_buf), &pwd) == 0 && - pwd != NULL) { - (*env)->SetLongField(env, obj, userID, pwd->pw_uid); - (*env)->SetLongField(env, obj, groupID, pwd->pw_gid); - jstr = (*env)->NewStringUTF(env, pwd->pw_name); - if (jstr == NULL) { - goto cleanUpAndReturn; - } - (*env)->SetObjectField(env, obj, userNameID, jstr); - } else { - (*env)->SetLongField(env, obj, userID, getuid()); - (*env)->SetLongField(env, obj, groupID, getgid()); - } -cleanUpAndReturn: - free(groups); - return; -} diff --git a/test/jdk/com/sun/security/auth/module/AllPlatforms.java b/test/jdk/com/sun/security/auth/module/AllPlatforms.java index 79eea7b4d23..6f7cbfb9c52 100644 --- a/test/jdk/com/sun/security/auth/module/AllPlatforms.java +++ b/test/jdk/com/sun/security/auth/module/AllPlatforms.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2025, 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 @@ -25,8 +25,11 @@ * @test * @bug 8039951 * @summary com.sun.security.auth.module missing classes on some platforms + * @modules java.base/jdk.internal.util * @run main/othervm AllPlatforms */ +import jdk.internal.util.OperatingSystem; + import javax.security.auth.login.Configuration; import javax.security.auth.login.LoginContext; import java.nio.file.Files; @@ -39,14 +42,14 @@ public class AllPlatforms { private static final String NT_MODULE = "NTLoginModule"; public static void main(String[] args) throws Exception { - login("cross-platform", + login(true, "cross-platform", UNIX_MODULE, "optional", NT_MODULE, "optional"); - login("windows", NT_MODULE, "required"); - login("unix", UNIX_MODULE, "required"); + login(OperatingSystem.isWindows(), "windows", NT_MODULE, "required"); + login(!OperatingSystem.isWindows(), "unix", UNIX_MODULE, "required"); } - static void login(String test, String... conf) throws Exception { + static void login(boolean shouldSucceed, String test, String... conf) throws Exception { System.out.println("Testing " + test + "..."); StringBuilder sb = new StringBuilder(); @@ -68,11 +71,19 @@ public class AllPlatforms { lc.login(); System.out.println(lc.getSubject()); lc.logout(); + if (!shouldSucceed) { + throw new RuntimeException("Should not succeed"); + } } catch (FailedLoginException e) { + if (shouldSucceed) { + throw new RuntimeException("Should succeed"); + } // This exception can occur in other platform module than the running one. - if(e.getMessage().startsWith("Failed in attempt to import")) { + if (e.getMessage().startsWith("Failed in attempt to import")) { System.out.println("Expected Exception found."); e.printStackTrace(System.out); + } else { + throw new RuntimeException("Unexpected error", e); } } } From 025041ba04f3ae3a149b9d57d0dde4afaef37f4c Mon Sep 17 00:00:00 2001 From: Artur Barashev Date: Thu, 22 Jan 2026 13:11:42 +0000 Subject: [PATCH 006/105] 8370885: Default namedGroups values are not being filtered against algorithm constraints Reviewed-by: hchao --- .../classes/sun/security/ssl/NamedGroup.java | 177 ++++++++++-------- .../ssl/CipherSuite/DefaultNamedGroups.java | 85 +++++++++ 2 files changed, 189 insertions(+), 73 deletions(-) create mode 100644 test/jdk/sun/security/ssl/CipherSuite/DefaultNamedGroups.java diff --git a/src/java.base/share/classes/sun/security/ssl/NamedGroup.java b/src/java.base/share/classes/sun/security/ssl/NamedGroup.java index abf973727f3..02524e67656 100644 --- a/src/java.base/share/classes/sun/security/ssl/NamedGroup.java +++ b/src/java.base/share/classes/sun/security/ssl/NamedGroup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -30,10 +30,12 @@ import java.security.spec.AlgorithmParameterSpec; import java.security.spec.ECParameterSpec; import java.security.spec.InvalidParameterSpecException; import java.security.spec.NamedParameterSpec; +import java.util.Arrays; import java.util.Collections; import java.util.EnumSet; import java.util.List; import java.util.ArrayList; +import java.util.Objects; import java.util.Set; import javax.crypto.KeyAgreement; import javax.crypto.spec.DHParameterSpec; @@ -463,10 +465,9 @@ enum NamedGroup { AlgorithmConstraints constraints, NamedGroupSpec type) { boolean hasFFDHEGroups = false; - for (String ng : sslConfig.namedGroups) { - NamedGroup namedGroup = NamedGroup.nameOf(ng); - if (namedGroup != null && - namedGroup.isAvailable && namedGroup.spec == type) { + for (NamedGroup namedGroup : + SupportedGroups.getGroupsFromConfig(sslConfig)) { + if (namedGroup.isAvailable && namedGroup.spec == type) { if (namedGroup.isPermitted(constraints)) { return true; } @@ -501,8 +502,8 @@ enum NamedGroup { // Is the named group supported? static boolean isEnabled(SSLConfiguration sslConfig, NamedGroup namedGroup) { - for (String ng : sslConfig.namedGroups) { - if (namedGroup.name.equalsIgnoreCase(ng)) { + for (NamedGroup ng : SupportedGroups.getGroupsFromConfig(sslConfig)) { + if (namedGroup.equals(ng)) { return true; } } @@ -516,12 +517,10 @@ enum NamedGroup { SSLConfiguration sslConfig, ProtocolVersion negotiatedProtocol, AlgorithmConstraints constraints, NamedGroupSpec[] types) { - for (String name : sslConfig.namedGroups) { - NamedGroup ng = NamedGroup.nameOf(name); - if (ng != null && ng.isAvailable && - (NamedGroupSpec.arrayContains(types, ng.spec)) && - ng.isAvailable(negotiatedProtocol) && - ng.isPermitted(constraints)) { + for (NamedGroup ng : SupportedGroups.getGroupsFromConfig(sslConfig)) { + if (ng.isAvailable && NamedGroupSpec.arrayContains(types, ng.spec) + && ng.isAvailable(negotiatedProtocol) + && ng.isPermitted(constraints)) { return ng; } } @@ -857,19 +856,92 @@ enum NamedGroup { } } + // Inner class encapsulating supported named groups. static final class SupportedGroups { - // the supported named groups, non-null immutable list + + // Default named groups. + private static final NamedGroup[] defaultGroups = new NamedGroup[]{ + // Hybrid key agreement + X25519MLKEM768, + + // Primary XDH (RFC 7748) curves + X25519, + + // Primary NIST Suite B curves + SECP256_R1, + SECP384_R1, + SECP521_R1, + + // Secondary XDH curves + X448, + + // FFDHE (RFC 7919) + FFDHE_2048, + FFDHE_3072, + FFDHE_4096, + FFDHE_6144, + FFDHE_8192 + }; + + // Filter default groups names against default constraints. + // Those are the values being displayed to the user with + // "java -XshowSettings:security:tls" command. + private static final String[] defaultNames = Arrays.stream( + defaultGroups) + .filter(ng -> ng.isAvailable) + .filter(ng -> ng.isPermitted(SSLAlgorithmConstraints.DEFAULT)) + .map(ng -> ng.name) + .toArray(String[]::new); + + private static final NamedGroup[] customizedGroups = + getCustomizedNamedGroups(); + + // Note: user-passed groups are not being filtered against default + // algorithm constraints here. They will be displayed as-is. + private static final String[] customizedNames = + customizedGroups == null ? + null : Arrays.stream(customizedGroups) + .map(ng -> ng.name) + .toArray(String[]::new); + + // Named group names for SSLConfiguration. static final String[] namedGroups; static { - // The value of the System Property defines a list of enabled named - // groups in preference order, separated with comma. For example: - // - // jdk.tls.namedGroups="secp521r1, secp256r1, ffdhe2048" - // - // If the System Property is not defined or the value is empty, the - // default groups and preferences will be used. + if (customizedNames != null) { + namedGroups = customizedNames; + } else { + if (defaultNames.length == 0) { + SSLLogger.logWarning("ssl", "No default named groups"); + } + namedGroups = defaultNames; + } + } + + // Avoid the group lookup for default and customized groups. + static NamedGroup[] getGroupsFromConfig(SSLConfiguration sslConfig) { + if (sslConfig.namedGroups == defaultNames) { + return defaultGroups; + } else if (sslConfig.namedGroups == customizedNames) { + return customizedGroups; + } else { + return Arrays.stream(sslConfig.namedGroups) + .map(NamedGroup::nameOf) + .filter(Objects::nonNull) + .toArray(NamedGroup[]::new); + } + } + + // The value of the System Property defines a list of enabled named + // groups in preference order, separated with comma. For example: + // + // jdk.tls.namedGroups="secp521r1, secp256r1, ffdhe2048" + // + // If the System Property is not defined or the value is empty, the + // default groups and preferences will be used. + private static NamedGroup[] getCustomizedNamedGroups() { String property = System.getProperty("jdk.tls.namedGroups"); + if (property != null && !property.isEmpty()) { // remove double quote marks from beginning/end of the property if (property.length() > 1 && property.charAt(0) == '"' && @@ -878,66 +950,25 @@ enum NamedGroup { } } - ArrayList groupList; if (property != null && !property.isEmpty()) { - String[] groups = property.split(","); - groupList = new ArrayList<>(groups.length); - for (String group : groups) { - group = group.trim(); - if (!group.isEmpty()) { - NamedGroup namedGroup = nameOf(group); - if (namedGroup != null) { - if (namedGroup.isAvailable) { - groupList.add(namedGroup.name); - } - } // ignore unknown groups - } - } + NamedGroup[] ret = Arrays.stream(property.split(",")) + .map(String::trim) + .map(NamedGroup::nameOf) + .filter(Objects::nonNull) + .filter(ng -> ng.isAvailable) + .toArray(NamedGroup[]::new); - if (groupList.isEmpty()) { + if (ret.length == 0) { throw new IllegalArgumentException( "System property jdk.tls.namedGroups(" + - property + ") contains no supported named groups"); - } - } else { // default groups - NamedGroup[] groups = new NamedGroup[] { - - // Hybrid key agreement - X25519MLKEM768, - - // Primary XDH (RFC 7748) curves - X25519, - - // Primary NIST Suite B curves - SECP256_R1, - SECP384_R1, - SECP521_R1, - - // Secondary XDH curves - X448, - - // FFDHE (RFC 7919) - FFDHE_2048, - FFDHE_3072, - FFDHE_4096, - FFDHE_6144, - FFDHE_8192, - }; - - groupList = new ArrayList<>(groups.length); - for (NamedGroup group : groups) { - if (group.isAvailable) { - groupList.add(group.name); - } + property + + ") contains no supported named groups"); } - if (groupList.isEmpty() && - SSLLogger.isOn() && SSLLogger.isOn("ssl")) { - SSLLogger.warning("No default named groups"); - } + return ret; } - namedGroups = groupList.toArray(new String[0]); + return null; } } } diff --git a/test/jdk/sun/security/ssl/CipherSuite/DefaultNamedGroups.java b/test/jdk/sun/security/ssl/CipherSuite/DefaultNamedGroups.java new file mode 100644 index 00000000000..44c9d566dc0 --- /dev/null +++ b/test/jdk/sun/security/ssl/CipherSuite/DefaultNamedGroups.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2026, 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. + */ + +import static jdk.test.lib.Asserts.assertFalse; +import static jdk.test.lib.Asserts.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import javax.net.ssl.SSLEngine; +import jdk.test.lib.security.SecurityUtils; + +/* + * @test + * @bug 8370885 + * @summary Default namedGroups values are not being filtered against + * algorithm constraints + * @library /javax/net/ssl/templates + * /test/lib + * @run main/othervm DefaultNamedGroups + */ + +public class DefaultNamedGroups extends SSLEngineTemplate { + + protected static final String DISABLED_NG = "secp256r1"; + protected static final List REFERENCE_NG = Stream.of( + "X25519MLKEM768", + "x25519", + "secp256r1", + "secp384r1", + "secp521r1", + "x448", + "ffdhe2048", + "ffdhe3072", + "ffdhe4096", + "ffdhe6144", + "ffdhe8192") + .sorted() + .toList(); + + protected DefaultNamedGroups() throws Exception { + super(); + } + + public static void main(String[] args) throws Exception { + SecurityUtils.addToDisabledTlsAlgs(DISABLED_NG); + var test = new DefaultNamedGroups(); + + for (SSLEngine engine : + new SSLEngine[]{test.serverEngine, test.clientEngine}) { + checkEngineDefaultNG(engine); + } + } + + private static void checkEngineDefaultNG(SSLEngine engine) { + var defaultConfigNG = new ArrayList<>(List.of( + engine.getSSLParameters().getNamedGroups())); + + assertFalse(defaultConfigNG.contains(DISABLED_NG)); + defaultConfigNG.add(DISABLED_NG); + assertTrue(REFERENCE_NG.equals( + defaultConfigNG.stream().sorted().toList()), + "Named groups returned by engine: " + defaultConfigNG); + } +} From 26aab3cccdbcf98c329c8d67093eb2dbf4b164e5 Mon Sep 17 00:00:00 2001 From: Patricio Chilano Mateo Date: Thu, 22 Jan 2026 14:56:23 +0000 Subject: [PATCH 007/105] 8373120: Virtual thread stuck in BLOCKED state Co-authored-by: Alan Bateman Reviewed-by: alanb --- .../classes/java/lang/VirtualThread.java | 25 ++-- .../stress/NotifiedThenTimedOutWait.java | 134 ++++++++++++++++++ 2 files changed, 148 insertions(+), 11 deletions(-) create mode 100644 test/jdk/java/lang/Thread/virtual/stress/NotifiedThenTimedOutWait.java diff --git a/src/java.base/share/classes/java/lang/VirtualThread.java b/src/java.base/share/classes/java/lang/VirtualThread.java index 93862db9105..5526618c67b 100644 --- a/src/java.base/share/classes/java/lang/VirtualThread.java +++ b/src/java.base/share/classes/java/lang/VirtualThread.java @@ -620,9 +620,12 @@ final class VirtualThread extends BaseVirtualThread { // Object.wait if (s == WAITING || s == TIMED_WAITING) { int newState; + boolean blocked; boolean interruptible = interruptibleWait; if (s == WAITING) { setState(newState = WAIT); + // may have been notified while in transition + blocked = notified && compareAndSetState(WAIT, BLOCKED); } else { // For timed-wait, a timeout task is scheduled to execute. The timeout // task will change the thread state to UNBLOCKED and submit the thread @@ -637,22 +640,22 @@ final class VirtualThread extends BaseVirtualThread { byte seqNo = ++timedWaitSeqNo; timeoutTask = schedule(() -> waitTimeoutExpired(seqNo), timeout, MILLISECONDS); setState(newState = TIMED_WAIT); + // May have been notified while in transition. This must be done while + // holding the monitor to avoid changing the state of a new timed wait call. + blocked = notified && compareAndSetState(TIMED_WAIT, BLOCKED); } } - // may have been notified while in transition to wait state - if (notified && compareAndSetState(newState, BLOCKED)) { - // may have even been unblocked already + if (blocked) { + // may have been unblocked already if (blockPermit && compareAndSetState(BLOCKED, UNBLOCKED)) { - submitRunContinuation(); + lazySubmitRunContinuation(); + } + } else { + // may have been interrupted while in transition to wait state + if (interruptible && interrupted && compareAndSetState(newState, UNBLOCKED)) { + lazySubmitRunContinuation(); } - return; - } - - // may have been interrupted while in transition to wait state - if (interruptible && interrupted && compareAndSetState(newState, UNBLOCKED)) { - submitRunContinuation(); - return; } return; } diff --git a/test/jdk/java/lang/Thread/virtual/stress/NotifiedThenTimedOutWait.java b/test/jdk/java/lang/Thread/virtual/stress/NotifiedThenTimedOutWait.java new file mode 100644 index 00000000000..0734a794b90 --- /dev/null +++ b/test/jdk/java/lang/Thread/virtual/stress/NotifiedThenTimedOutWait.java @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2026, 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 8373120 + * @summary Stress test two consecutive timed Object.wait calls where only the first one is notified. + * @run main/othervm -XX:CompileCommand=exclude,java.lang.VirtualThread::afterYield NotifiedThenTimedOutWait 1 100 100 + */ + +/* + * @test + * @run main/othervm -XX:CompileCommand=exclude,java.lang.VirtualThread::afterYield NotifiedThenTimedOutWait 2 100 100 + */ + +import java.time.Instant; +import java.util.concurrent.Phaser; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.ThreadLocalRandom; + +public class NotifiedThenTimedOutWait { + public static void main(String[] args) throws Exception { + int race = (args.length > 0) ? Integer.parseInt(args[0]) : 1; + int nruns = (args.length > 1) ? Integer.parseInt(args[1]) : 100; + int iterations = (args.length > 2) ? Integer.parseInt(args[2]) : 100; + + for (int i = 1; i <= nruns; i++) { + System.out.println(Instant.now() + " => " + i + " of " + nruns); + switch (race) { + case 1 -> race1(iterations); + case 2 -> race2(iterations); + } + } + } + + /** + * Barrier in synchronized block. + */ + private static void race1(int iterations) throws InterruptedException { + final int timeout = 1; + var lock = new Object(); + var start = new Phaser(2); + var end = new Phaser(2); + + var vthread = Thread.ofVirtual().start(() -> { + try { + for (int j = 0; j < iterations; j++) { + synchronized (lock) { + start.arriveAndAwaitAdvance(); + lock.wait(timeout); + lock.wait(timeout); + } + end.arriveAndAwaitAdvance(); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + }); + + ThreadFactory factory = ThreadLocalRandom.current().nextBoolean() + ? Thread.ofPlatform().factory() : Thread.ofVirtual().factory(); + var notifier = factory.newThread(() -> { + for (int j = 0; j < iterations; j++) { + start.arriveAndAwaitAdvance(); + synchronized (lock) { + lock.notify(); + } + end.arriveAndAwaitAdvance(); + } + }); + notifier.start(); + + vthread.join(); + notifier.join(); + } + + /** + * Barrier before synchronized block. + */ + private static void race2(int iterations) throws InterruptedException { + final int timeout = 1; + var lock = new Object(); + var start = new Phaser(2); + + var vthread = Thread.startVirtualThread(() -> { + try { + for (int i = 0; i < iterations; i++) { + start.arriveAndAwaitAdvance(); + synchronized (lock) { + lock.wait(timeout); + lock.wait(timeout); + } + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + }); + + ThreadFactory factory = ThreadLocalRandom.current().nextBoolean() + ? Thread.ofPlatform().factory() : Thread.ofVirtual().factory(); + var notifier = factory.newThread(() -> { + for (int i = 0; i < iterations; i++) { + start.arriveAndAwaitAdvance(); + synchronized (lock) { + lock.notify(); + } + } + }); + notifier.start(); + + vthread.join(); + notifier.join(); + } +} From 07f6617e0b2752b538b6c43250dd0bb65fd8c695 Mon Sep 17 00:00:00 2001 From: Brian Burkhalter Date: Thu, 22 Jan 2026 16:11:33 +0000 Subject: [PATCH 008/105] 8367284: (fs) Support current working directory target in SecureDirectoryStream.move Reviewed-by: alanb --- .../java/nio/file/SecureDirectoryStream.java | 15 ++++++----- .../sun/nio/fs/UnixSecureDirectoryStream.java | 15 ++++++----- .../nio/file/DirectoryStream/SecureDS.java | 27 +++++++++++++++---- 3 files changed, 38 insertions(+), 19 deletions(-) diff --git a/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java b/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java index 4348c60f5e2..92a292bbac6 100644 --- a/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java +++ b/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2026, 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 @@ -185,8 +185,8 @@ public interface SecureDirectoryStream /** * Move a file from this directory to another directory. * - *

This method works in a similar manner to {@link Files#move move} - * method when the {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} option + *

This method works in a similar manner to {@link Files#move Files.move} + * when the {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} option * is specified. That is, this method moves a file as an atomic file system * operation. If the {@code srcpath} parameter is an {@link Path#isAbsolute * absolute} path then it locates the source file. If the parameter is a @@ -194,14 +194,15 @@ public interface SecureDirectoryStream * the {@code targetpath} parameter is absolute then it locates the target * file (the {@code targetdir} parameter is ignored). If the parameter is * a relative path it is located relative to the open directory identified - * by the {@code targetdir} parameter. In all cases, if the target file - * exists then it is implementation specific if it is replaced or this - * method fails. + * by the {@code targetdir} parameter, unless {@code targetdir} is + * {@code null}, in which case it is located relative to the current + * working directory. In all cases, if the target file exists then it is + * implementation specific if it is replaced or this method fails. * * @param srcpath * the name of the file to move * @param targetdir - * the destination directory + * the destination directory; can be {@code null} * @param targetpath * the name to give the file in the destination directory * diff --git a/src/java.base/unix/classes/sun/nio/fs/UnixSecureDirectoryStream.java b/src/java.base/unix/classes/sun/nio/fs/UnixSecureDirectoryStream.java index 5c0693870e6..bafcd06d9e7 100644 --- a/src/java.base/unix/classes/sun/nio/fs/UnixSecureDirectoryStream.java +++ b/src/java.base/unix/classes/sun/nio/fs/UnixSecureDirectoryStream.java @@ -202,21 +202,21 @@ class UnixSecureDirectoryStream { UnixPath from = getName(fromObj); UnixPath to = getName(toObj); - if (dir == null) - throw new NullPointerException(); - if (!(dir instanceof UnixSecureDirectoryStream)) + if (dir != null && !(dir instanceof UnixSecureDirectoryStream)) throw new ProviderMismatchException(); UnixSecureDirectoryStream that = (UnixSecureDirectoryStream)dir; + int todfd = that != null ? that.dfd : AT_FDCWD; // lock ordering doesn't matter this.ds.readLock().lock(); try { - that.ds.readLock().lock(); + if (that != null) + that.ds.readLock().lock(); try { - if (!this.ds.isOpen() || !that.ds.isOpen()) + if (!this.ds.isOpen() || (that != null && !that.ds.isOpen())) throw new ClosedDirectoryStreamException(); try { - renameat(this.dfd, from.asByteArray(), that.dfd, to.asByteArray()); + renameat(this.dfd, from.asByteArray(), todfd, to.asByteArray()); } catch (UnixException x) { if (x.errno() == EXDEV) { throw new AtomicMoveNotSupportedException( @@ -225,7 +225,8 @@ class UnixSecureDirectoryStream x.rethrowAsIOException(from, to); } } finally { - that.ds.readLock().unlock(); + if (that != null) + that.ds.readLock().unlock(); } } finally { this.ds.readLock().unlock(); diff --git a/test/jdk/java/nio/file/DirectoryStream/SecureDS.java b/test/jdk/java/nio/file/DirectoryStream/SecureDS.java index d5d4b1904ea..21204ba980a 100644 --- a/test/jdk/java/nio/file/DirectoryStream/SecureDS.java +++ b/test/jdk/java/nio/file/DirectoryStream/SecureDS.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, 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 @@ -292,6 +292,27 @@ public class SecureDS { } } + // Test: move to cwd + final String TEXT = "Sous le pont Mirabeau coule la Seine"; + Path file = Path.of("file"); + Path filepath = dir.resolve(file); + Path cwd = Path.of(System.getProperty("user.dir")); + Path result = cwd.resolve(file); + Files.writeString(filepath, TEXT); + try (DirectoryStream ds = Files.newDirectoryStream(dir);) { + if (ds instanceof SecureDirectoryStream sds) { + sds.move(file, null, file); + if (!TEXT.equals(Files.readString(result))) + throw new RuntimeException(result + " content incorrect"); + } else { + throw new RuntimeException("Not a SecureDirectoryStream"); + } + } finally { + boolean fileDeleted = Files.deleteIfExists(filepath); + if (!fileDeleted) + Files.deleteIfExists(result); + } + // clean-up delete(dir1); delete(dir2); @@ -334,10 +355,6 @@ public class SecureDS { stream.move(null, stream, file); shouldNotGetHere(); } catch (NullPointerException x) { } - try { - stream.move(file, null, file); - shouldNotGetHere(); - } catch (NullPointerException x) { } try { stream.move(file, stream, null); shouldNotGetHere(); From 8c82b58db960a178566514731e1f8dcbc59b0161 Mon Sep 17 00:00:00 2001 From: Alexander Zuev Date: Thu, 22 Jan 2026 16:36:24 +0000 Subject: [PATCH 009/105] 8286258: [Accessibility,macOS,VoiceOver] VoiceOver reads the spinner value wrong and sometime partially Reviewed-by: psadhukhan, asemenov --- .../awt/a11y/NavigableTextAccessibility.h | 3 +- .../awt/a11y/NavigableTextAccessibility.m | 27 +++++- .../awt/a11y/SpinboxAccessibility.m | 27 +++++- .../CustomSpinnerAccessibilityTest.java | 86 +++++++++++++++++++ 4 files changed, 139 insertions(+), 4 deletions(-) create mode 100644 test/jdk/javax/accessibility/JSpinner/CustomSpinnerAccessibilityTest.java diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.h b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.h index ebf314c7394..9a528879a5d 100644 --- a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.h +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2021, JetBrains s.r.o.. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -29,5 +29,6 @@ @interface NavigableTextAccessibility : CommonComponentAccessibility @property(readonly) BOOL accessibleIsPasswordText; +@property BOOL announceEditUpdates; @end diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.m b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.m index 138d502f10f..8e241e65b96 100644 --- a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.m +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/NavigableTextAccessibility.m @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2021, JetBrains s.r.o.. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -60,6 +60,22 @@ static jmethodID sjm_getAccessibleEditableText = NULL; return [fJavaRole isEqualToString:@"passwordtext"]; } +- (id)init { + self = [super init]; + if (self) { + _announceEditUpdates = YES; + } + return self; +} + +- (void)suppressEditUpdates { + _announceEditUpdates = NO; +} + +- (void)resumeEditUpdates { + _announceEditUpdates = YES; +} + // NSAccessibilityElement protocol methods - (NSRect)accessibilityFrameForRange:(NSRange)range @@ -117,6 +133,9 @@ static jmethodID sjm_getAccessibleEditableText = NULL; - (NSString *)accessibilityStringForRange:(NSRange)range { + if (!_announceEditUpdates) { + return @""; + } JNIEnv *env = [ThreadUtilities getJNIEnv]; GET_CACCESSIBLETEXT_CLASS_RETURN(nil); DECLARE_STATIC_METHOD_RETURN(jm_getStringForRange, sjc_CAccessibleText, "getStringForRange", @@ -306,6 +325,12 @@ static jmethodID sjm_getAccessibleEditableText = NULL; return [super accessibilityParent]; } +- (void)postSelectedTextChanged +{ + [super postSelectedTextChanged]; + [self resumeEditUpdates]; +} + /* * Other text methods - (NSRange)accessibilitySharedCharacterRange; diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/SpinboxAccessibility.m b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/SpinboxAccessibility.m index 4dac6bd93f9..0cec7f3eb2c 100644 --- a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/SpinboxAccessibility.m +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/SpinboxAccessibility.m @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -24,6 +24,7 @@ */ #import "SpinboxAccessibility.h" +#import "ThreadUtilities.h" #define INCREMENT 0 #define DECREMENT 1 @@ -44,7 +45,15 @@ - (id _Nullable)accessibilityValue { - return [super accessibilityValue]; + id val = [super accessibilityValue]; + NSArray *clist = [super accessibilityChildren]; + for (NSUInteger i = 0; i < [clist count]; i++) { + id child = [clist objectAtIndex:i]; + if ([child conformsToProtocol:@protocol(NSAccessibilityNavigableStaticText)]) { + val = [child accessibilityValue]; + } + } + return val; } - (BOOL)accessibilityPerformIncrement @@ -68,4 +77,18 @@ return [super accessibilityParent]; } +- (void)postValueChanged +{ + AWT_ASSERT_APPKIT_THREAD; + NSAccessibilityPostNotification(self, NSAccessibilityValueChangedNotification); + NSArray *clist = [super accessibilityChildren]; + for (NSUInteger i = 0; i < [clist count]; i++) { + id child = [clist objectAtIndex:i]; + if ([child conformsToProtocol:@protocol(NSAccessibilityNavigableStaticText)]) { + NSAccessibilityPostNotification(child, NSAccessibilityLayoutChangedNotification); + [child suppressEditUpdates]; + } + } +} + @end diff --git a/test/jdk/javax/accessibility/JSpinner/CustomSpinnerAccessibilityTest.java b/test/jdk/javax/accessibility/JSpinner/CustomSpinnerAccessibilityTest.java new file mode 100644 index 00000000000..12c98c95110 --- /dev/null +++ b/test/jdk/javax/accessibility/JSpinner/CustomSpinnerAccessibilityTest.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2026, 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. + */ + +import java.awt.GridLayout; +import java.lang.reflect.InvocationTargetException; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.JSpinner; +import javax.swing.SpinnerListModel; + +/* + * @test + * @bug 8286258 + * @library /java/awt/regtesthelpers + * @build PassFailJFrame + * @requires (os.family == "mac") + * @summary Checks that JSpinner with custom model announces + * the value every time it is changed + * @run main/manual CustomSpinnerAccessibilityTest + */ + +public class CustomSpinnerAccessibilityTest extends JPanel { + private static final String INSTRUCTIONS = """ + 1. Turn on VoiceOver + 2. In the window named "Test UI" click on the text editor inside the + spinner component + 3. Using up and down arrows change current month + 4. Wait for the VoiceOver to finish speaking + 5. Repeat steps 3 and 4 couple more times + + If every time value of the spinner is changed VoiceOver + announces the new value click "Pass". + If instead the value is narrated only partially + and the new value is never fully narrated press "Fail". + """; + + public CustomSpinnerAccessibilityTest() { + super(new GridLayout(0, 2)); + String[] monthStrings = new java.text.DateFormatSymbols().getMonths(); + int lastIndex = monthStrings.length - 1; + if (monthStrings[lastIndex] == null + || monthStrings[lastIndex].length() <= 0) { + String[] tmp = new String[lastIndex]; + System.arraycopy(monthStrings, 0, + tmp, 0, lastIndex); + monthStrings = tmp; + } + + SpinnerListModel model = new SpinnerListModel(monthStrings); + JLabel label = new JLabel("Month: "); + add(label); + JSpinner spinner = new JSpinner(model); + label.setLabelFor(spinner); + add(spinner); + } + + public static void main(String[] args) throws InterruptedException, + InvocationTargetException { + PassFailJFrame.builder() + .title("Custom Spinner Accessibility Test") + .instructions(INSTRUCTIONS) + .testUI(CustomSpinnerAccessibilityTest::new) + .build() + .awaitAndCheck(); + } +} From 5dfda66e13df5a88a66a6e4b1ae1bcd4e20ac674 Mon Sep 17 00:00:00 2001 From: Henry Jen Date: Thu, 22 Jan 2026 17:21:44 +0000 Subject: [PATCH 010/105] 8373928: 4 Dangling pointer defect groups in java.c Reviewed-by: bpb, alanb, jpai, jwaters --- src/java.base/share/native/libjli/java.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/java.base/share/native/libjli/java.c b/src/java.base/share/native/libjli/java.c index 6072bff50c6..4621ab588d1 100644 --- a/src/java.base/share/native/libjli/java.c +++ b/src/java.base/share/native/libjli/java.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1995, 2026, 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 @@ -1505,6 +1505,7 @@ InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn) r = ifn->CreateJavaVM(pvm, (void **)penv, &args); JLI_MemFree(options); + options = NULL; return r == JNI_OK; } @@ -2203,6 +2204,7 @@ FreeKnownVMs() knownVMs[i].name = NULL; } JLI_MemFree(knownVMs); + knownVMs = NULL; } /* @@ -2276,8 +2278,9 @@ ShowSplashScreen() (void)UnsetEnv(SPLASH_JAR_ENV_ENTRY); JLI_MemFree(splash_jar_entry); + splash_jar_entry = NULL; JLI_MemFree(splash_file_entry); - + splash_file_entry = NULL; } static const char* GetFullVersion() From 96a2649e29b8b4ff9b65b2314d430bc7637c5c61 Mon Sep 17 00:00:00 2001 From: Hai-May Chao Date: Thu, 22 Jan 2026 17:41:00 +0000 Subject: [PATCH 011/105] 8373408: SHA1withECDSA is not required for ECDHE and ECDSA Reviewed-by: djelinski, ascarpino --- src/java.base/share/classes/sun/security/ssl/JsseJce.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/java.base/share/classes/sun/security/ssl/JsseJce.java b/src/java.base/share/classes/sun/security/ssl/JsseJce.java index 3ffc2d84168..1e610eeab1d 100644 --- a/src/java.base/share/classes/sun/security/ssl/JsseJce.java +++ b/src/java.base/share/classes/sun/security/ssl/JsseJce.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2026, 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 @@ -165,7 +165,6 @@ final class JsseJce { static { boolean mediator = true; try { - Signature.getInstance(SIGNATURE_ECDSA); Signature.getInstance(SIGNATURE_RAWECDSA); KeyAgreement.getInstance("ECDH"); KeyFactory.getInstance("EC"); From f3121d10237a933087dde926f83a12ce826cde02 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 22 Jan 2026 20:16:44 +0000 Subject: [PATCH 012/105] 8373931: Test javax/sound/sampled/Clip/AutoCloseTimeCheck.java timed out Reviewed-by: dholmes, dnguyen, kizune --- test/jdk/javax/sound/sampled/Clip/AutoCloseTimeCheck.java | 1 + 1 file changed, 1 insertion(+) diff --git a/test/jdk/javax/sound/sampled/Clip/AutoCloseTimeCheck.java b/test/jdk/javax/sound/sampled/Clip/AutoCloseTimeCheck.java index f823175ede8..edacc50fa42 100644 --- a/test/jdk/javax/sound/sampled/Clip/AutoCloseTimeCheck.java +++ b/test/jdk/javax/sound/sampled/Clip/AutoCloseTimeCheck.java @@ -39,6 +39,7 @@ import static javax.sound.sampled.AudioSystem.NOT_SPECIFIED; /** * @test + * @key sound * @bug 8202264 */ public final class AutoCloseTimeCheck { From d6ebcf8a4f42b8e157083be90271e0df3b631033 Mon Sep 17 00:00:00 2001 From: Kelvin Nilsen Date: Thu, 22 Jan 2026 21:28:57 +0000 Subject: [PATCH 013/105] 8357471: GenShen: Share collector reserves between young and old Reviewed-by: wkemper --- .../shenandoahAdaptiveHeuristics.cpp | 7 +- .../shenandoahAdaptiveHeuristics.hpp | 6 +- .../shenandoahAggressiveHeuristics.cpp | 7 +- .../shenandoahAggressiveHeuristics.hpp | 6 +- .../shenandoahCompactHeuristics.cpp | 7 +- .../shenandoahCompactHeuristics.hpp | 6 +- .../shenandoahGenerationalHeuristics.cpp | 20 +- .../shenandoahGenerationalHeuristics.hpp | 2 +- .../heuristics/shenandoahGlobalHeuristics.cpp | 244 +++++++--- .../heuristics/shenandoahGlobalHeuristics.hpp | 6 +- .../heuristics/shenandoahHeuristics.cpp | 4 +- .../heuristics/shenandoahHeuristics.hpp | 13 +- .../heuristics/shenandoahOldHeuristics.cpp | 380 +++++++++------ .../heuristics/shenandoahOldHeuristics.hpp | 52 +- .../shenandoahPassiveHeuristics.cpp | 7 +- .../shenandoahPassiveHeuristics.hpp | 6 +- .../heuristics/shenandoahStaticHeuristics.cpp | 7 +- .../heuristics/shenandoahStaticHeuristics.hpp | 6 +- .../heuristics/shenandoahYoungHeuristics.cpp | 17 +- .../heuristics/shenandoahYoungHeuristics.hpp | 6 +- .../gc/shenandoah/shenandoahCollectionSet.cpp | 4 + .../gc/shenandoah/shenandoahCollectionSet.hpp | 7 + .../gc/shenandoah/shenandoahConcurrentGC.cpp | 12 +- .../share/gc/shenandoah/shenandoahFreeSet.cpp | 452 ++++++++++-------- .../share/gc/shenandoah/shenandoahFreeSet.hpp | 94 ++-- .../share/gc/shenandoah/shenandoahFullGC.cpp | 10 +- .../gc/shenandoah/shenandoahGeneration.cpp | 135 +++--- .../gc/shenandoah/shenandoahGeneration.hpp | 21 +- .../shenandoahGenerationalFullGC.cpp | 10 +- .../shenandoah/shenandoahGenerationalHeap.cpp | 222 ++++++--- .../shenandoah/shenandoahGenerationalHeap.hpp | 2 +- .../share/gc/shenandoah/shenandoahHeap.cpp | 47 +- .../share/gc/shenandoah/shenandoahHeap.hpp | 2 + .../gc/shenandoah/shenandoahHeapRegion.cpp | 4 + .../share/gc/shenandoah/shenandoahOldGC.cpp | 9 +- .../gc/shenandoah/shenandoahOldGeneration.cpp | 3 +- .../gc/shenandoah/shenandoahOldGeneration.hpp | 4 +- .../shenandoah/shenandoahScanRemembered.cpp | 3 +- .../gc/shenandoah/shenandoahVerifier.cpp | 9 +- .../gc/shenandoah/shenandoah_globals.hpp | 35 +- .../test_shenandoahOldHeuristic.cpp | 48 +- 41 files changed, 1228 insertions(+), 714 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp index 7a8bd55c795..46d9f19d35f 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp @@ -68,9 +68,9 @@ ShenandoahAdaptiveHeuristics::ShenandoahAdaptiveHeuristics(ShenandoahSpaceInfo* ShenandoahAdaptiveHeuristics::~ShenandoahAdaptiveHeuristics() {} -void ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) { +size_t ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) { size_t garbage_threshold = ShenandoahHeapRegion::region_size_bytes() * ShenandoahGarbageThreshold / 100; // The logic for cset selection in adaptive is as follows: @@ -124,6 +124,7 @@ void ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(Shenand cur_garbage = new_garbage; } } + return 0; } void ShenandoahAdaptiveHeuristics::record_cycle_start() { diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp index 1ba18f37c2b..c4fdf819391 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp @@ -108,9 +108,9 @@ public: virtual ~ShenandoahAdaptiveHeuristics(); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) override; + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) override; virtual void record_cycle_start() override; virtual void record_success_concurrent() override; diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp index a833e39631c..990b59ec853 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp @@ -39,15 +39,16 @@ ShenandoahAggressiveHeuristics::ShenandoahAggressiveHeuristics(ShenandoahSpaceIn SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahEvacReserveOverflow); } -void ShenandoahAggressiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t free) { +size_t ShenandoahAggressiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t free) { for (size_t idx = 0; idx < size; idx++) { ShenandoahHeapRegion* r = data[idx].get_region(); if (r->garbage() > 0) { cset->add_region(r); } } + return 0; } bool ShenandoahAggressiveHeuristics::should_start_gc() { diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp index 5075258f1ce..25c8635489f 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp @@ -35,9 +35,9 @@ class ShenandoahAggressiveHeuristics : public ShenandoahHeuristics { public: ShenandoahAggressiveHeuristics(ShenandoahSpaceInfo* space_info); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t free); + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t free); virtual bool should_start_gc(); diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp index 28673b28612..09a8394a4b1 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp @@ -76,9 +76,9 @@ bool ShenandoahCompactHeuristics::should_start_gc() { return ShenandoahHeuristics::should_start_gc(); } -void ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) { +size_t ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) { // Do not select too large CSet that would overflow the available free space size_t max_cset = actual_free * 3 / 4; @@ -97,4 +97,5 @@ void ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(Shenando cset->add_region(r); } } + return 0; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp index 21ec99eabc0..4988d5d495d 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp @@ -37,9 +37,9 @@ public: virtual bool should_start_gc(); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free); + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free); virtual const char* name() { return "Compact"; } virtual bool is_diagnostic() { return false; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp index b14d72f249b..ee315ce5c7e 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp @@ -37,7 +37,7 @@ ShenandoahGenerationalHeuristics::ShenandoahGenerationalHeuristics(ShenandoahGen : ShenandoahAdaptiveHeuristics(generation), _generation(generation) { } -void ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { +size_t ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { assert(collection_set->is_empty(), "Must be empty"); auto heap = ShenandoahGenerationalHeap::heap(); @@ -168,16 +168,12 @@ void ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectio byte_size_in_proper_unit(total_garbage), proper_unit_for_byte_size(total_garbage)); size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage); - bool doing_promote_in_place = (humongous_regions_promoted + regular_regions_promoted_in_place > 0); - if (doing_promote_in_place || (preselected_candidates > 0) || (immediate_percent <= ShenandoahImmediateThreshold)) { - // Only young collections need to prime the collection set. - if (_generation->is_young()) { - heap->old_generation()->heuristics()->prime_collection_set(collection_set); - } + size_t add_regions_to_old = 0; + if (doing_promote_in_place || (preselected_candidates > 0) || (immediate_percent <= ShenandoahImmediateThreshold)) { // Call the subclasses to add young-gen regions into the collection set. - choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free); + add_regions_to_old = choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free); } if (collection_set->has_old_regions()) { @@ -194,6 +190,7 @@ void ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectio regular_regions_promoted_free, immediate_regions, immediate_garbage); + return add_regions_to_old; } @@ -210,13 +207,6 @@ size_t ShenandoahGenerationalHeuristics::add_preselected_regions_to_collection_s assert(ShenandoahGenerationalHeap::heap()->is_tenurable(r), "Preselected regions must have tenure age"); // Entire region will be promoted, This region does not impact young-gen or old-gen evacuation reserve. // This region has been pre-selected and its impact on promotion reserve is already accounted for. - - // r->used() is r->garbage() + r->get_live_data_bytes() - // Since all live data in this region is being evacuated from young-gen, it is as if this memory - // is garbage insofar as young-gen is concerned. Counting this as garbage reduces the need to - // reclaim highly utilized young-gen regions just for the sake of finding min_garbage to reclaim - // within young-gen memory. - cur_young_garbage += r->garbage(); cset->add_region(r); } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp index 31c016bb4b7..9b4c93af9b4 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp @@ -44,7 +44,7 @@ class ShenandoahGenerationalHeuristics : public ShenandoahAdaptiveHeuristics { public: explicit ShenandoahGenerationalHeuristics(ShenandoahGeneration* generation); - void choose_collection_set(ShenandoahCollectionSet* collection_set) override; + size_t choose_collection_set(ShenandoahCollectionSet* collection_set) override; protected: ShenandoahGeneration* _generation; diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp index 51805b205dd..f47371c14d5 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp @@ -24,6 +24,7 @@ */ #include "gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp" +#include "gc/shenandoah/shenandoahAsserts.hpp" #include "gc/shenandoah/shenandoahCollectorPolicy.hpp" #include "gc/shenandoah/shenandoahGenerationalHeap.inline.hpp" #include "gc/shenandoah/shenandoahGlobalGeneration.hpp" @@ -35,13 +36,14 @@ ShenandoahGlobalHeuristics::ShenandoahGlobalHeuristics(ShenandoahGlobalGeneratio } -void ShenandoahGlobalHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) { +size_t ShenandoahGlobalHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) { // Better select garbage-first regions QuickSort::sort(data, (int) size, compare_by_garbage); choose_global_collection_set(cset, data, size, actual_free, 0 /* cur_young_garbage */); + return 0; } @@ -49,94 +51,212 @@ void ShenandoahGlobalHeuristics::choose_global_collection_set(ShenandoahCollecti const ShenandoahHeuristics::RegionData* data, size_t size, size_t actual_free, size_t cur_young_garbage) const { + shenandoah_assert_heaplocked_or_safepoint(); auto heap = ShenandoahGenerationalHeap::heap(); + auto free_set = heap->free_set(); size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes(); size_t capacity = heap->soft_max_capacity(); + size_t garbage_threshold = region_size_bytes * ShenandoahGarbageThreshold / 100; size_t ignore_threshold = region_size_bytes * ShenandoahIgnoreGarbageThreshold / 100; size_t young_evac_reserve = heap->young_generation()->get_evacuation_reserve(); + size_t original_young_evac_reserve = young_evac_reserve; size_t old_evac_reserve = heap->old_generation()->get_evacuation_reserve(); - size_t max_young_cset = (size_t) (young_evac_reserve / ShenandoahEvacWaste); - size_t young_cur_cset = 0; - size_t max_old_cset = (size_t) (old_evac_reserve / ShenandoahOldEvacWaste); - size_t old_cur_cset = 0; + size_t old_promo_reserve = heap->old_generation()->get_promoted_reserve(); - // Figure out how many unaffiliated young regions are dedicated to mutator and to evacuator. Allow the young - // collector's unaffiliated regions to be transferred to old-gen if old-gen has more easily reclaimed garbage - // than young-gen. At the end of this cycle, any excess regions remaining in old-gen will be transferred back - // to young. Do not transfer the mutator's unaffiliated regions to old-gen. Those must remain available - // to the mutator as it needs to be able to consume this memory during concurrent GC. - - size_t unaffiliated_young_regions = heap->young_generation()->free_unaffiliated_regions(); + size_t unaffiliated_young_regions = free_set->collector_unaffiliated_regions(); size_t unaffiliated_young_memory = unaffiliated_young_regions * region_size_bytes; + size_t unaffiliated_old_regions = free_set->old_collector_unaffiliated_regions(); + size_t unaffiliated_old_memory = unaffiliated_old_regions * region_size_bytes; - if (unaffiliated_young_memory > max_young_cset) { - size_t unaffiliated_mutator_memory = unaffiliated_young_memory - max_young_cset; - unaffiliated_young_memory -= unaffiliated_mutator_memory; - unaffiliated_young_regions = unaffiliated_young_memory / region_size_bytes; // round down - unaffiliated_young_memory = unaffiliated_young_regions * region_size_bytes; + // Figure out how many unaffiliated regions are dedicated to Collector and OldCollector reserves. Let these + // be shuffled between young and old generations in order to expedite evacuation of whichever regions have the + // most garbage, regardless of whether these garbage-first regions reside in young or old generation. + // Excess reserves will be transferred back to the mutator after collection set has been chosen. At the end + // of evacuation, any reserves not consumed by evacuation will also be transferred to the mutator free set. + + // Truncate reserves to only target unaffiliated memory + size_t shared_reserve_regions = 0; + if (young_evac_reserve > unaffiliated_young_memory) { + shared_reserve_regions += unaffiliated_young_regions; + } else { + size_t delta_regions = young_evac_reserve / region_size_bytes; + shared_reserve_regions += delta_regions; } + young_evac_reserve = 0; + size_t total_old_reserve = old_evac_reserve + old_promo_reserve; + if (total_old_reserve > unaffiliated_old_memory) { + // Give all the unaffiliated memory to the shared reserves. Leave the rest for promo reserve. + shared_reserve_regions += unaffiliated_old_regions; + old_promo_reserve = total_old_reserve - unaffiliated_old_memory; + } else { + size_t delta_regions = old_evac_reserve / region_size_bytes; + shared_reserve_regions += delta_regions; + } + old_evac_reserve = 0; + assert(shared_reserve_regions <= + (heap->young_generation()->free_unaffiliated_regions() + heap->old_generation()->free_unaffiliated_regions()), + "simple math"); - // We'll affiliate these unaffiliated regions with either old or young, depending on need. - max_young_cset -= unaffiliated_young_memory; + size_t shared_reserves = shared_reserve_regions * region_size_bytes; + size_t committed_from_shared_reserves = 0; - // Keep track of how many regions we plan to transfer from young to old. - size_t regions_transferred_to_old = 0; + size_t promo_bytes = 0; + size_t old_evac_bytes = 0; + size_t young_evac_bytes = 0; - size_t free_target = (capacity * ShenandoahMinFreeThreshold) / 100 + max_young_cset; + size_t consumed_by_promo = 0; // promo_bytes * ShenandoahPromoEvacWaste + size_t consumed_by_old_evac = 0; // old_evac_bytes * ShenandoahOldEvacWaste + size_t consumed_by_young_evac = 0; // young_evac_bytes * ShenandoahEvacWaste + + // Of the memory reclaimed by GC, some of this will need to be reserved for the next GC collection. Use the current + // young reserve as an approximation of the future Collector reserve requirement. Try to end with at least + // (capacity * ShenandoahMinFreeThreshold) / 100 bytes available to the mutator. + size_t free_target = (capacity * ShenandoahMinFreeThreshold) / 100 + original_young_evac_reserve; size_t min_garbage = (free_target > actual_free) ? (free_target - actual_free) : 0; - log_info(gc, ergo)("Adaptive CSet Selection for GLOBAL. Max Young Evacuation: %zu" - "%s, Max Old Evacuation: %zu%s, Max Either Evacuation: %zu%s, Actual Free: %zu%s.", - byte_size_in_proper_unit(max_young_cset), proper_unit_for_byte_size(max_young_cset), - byte_size_in_proper_unit(max_old_cset), proper_unit_for_byte_size(max_old_cset), - byte_size_in_proper_unit(unaffiliated_young_memory), proper_unit_for_byte_size(unaffiliated_young_memory), - byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free)); + size_t aged_regions_promoted = 0; + size_t young_regions_evacuated = 0; + size_t old_regions_evacuated = 0; + log_info(gc, ergo)("Adaptive CSet Selection for GLOBAL. Discretionary evacuation budget (for either old or young): %zu%s" + ", Actual Free: %zu%s.", + byte_size_in_proper_unit(shared_reserves), proper_unit_for_byte_size(shared_reserves), + byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free)); + + size_t cur_garbage = cur_young_garbage; for (size_t idx = 0; idx < size; idx++) { ShenandoahHeapRegion* r = data[idx].get_region(); assert(!cset->is_preselected(r->index()), "There should be no preselected regions during GLOBAL GC"); bool add_region = false; - if (r->is_old() || heap->is_tenurable(r)) { - size_t new_cset = old_cur_cset + r->get_live_data_bytes(); - if ((r->garbage() > garbage_threshold)) { - while ((new_cset > max_old_cset) && (unaffiliated_young_regions > 0)) { - unaffiliated_young_regions--; - regions_transferred_to_old++; - max_old_cset += region_size_bytes / ShenandoahOldEvacWaste; + size_t region_garbage = r->garbage(); + size_t new_garbage = cur_garbage + region_garbage; + bool add_regardless = (region_garbage > ignore_threshold) && (new_garbage < min_garbage); + size_t live_bytes = r->get_live_data_bytes(); + if (add_regardless || (region_garbage >= garbage_threshold)) { + if (r->is_old()) { + size_t anticipated_consumption = (size_t) (live_bytes * ShenandoahOldEvacWaste); + size_t new_old_consumption = consumed_by_old_evac + anticipated_consumption; + size_t new_old_evac_reserve = old_evac_reserve; + size_t proposed_old_region_expansion = 0; + while ((new_old_consumption > new_old_evac_reserve) && (committed_from_shared_reserves < shared_reserves)) { + committed_from_shared_reserves += region_size_bytes; + proposed_old_region_expansion++; + new_old_evac_reserve += region_size_bytes; } - } - if ((new_cset <= max_old_cset) && (r->garbage() > garbage_threshold)) { - add_region = true; - old_cur_cset = new_cset; - } - } else { - assert(r->is_young() && !heap->is_tenurable(r), "DeMorgan's law (assuming r->is_affiliated)"); - size_t new_cset = young_cur_cset + r->get_live_data_bytes(); - size_t region_garbage = r->garbage(); - size_t new_garbage = cur_young_garbage + region_garbage; - bool add_regardless = (region_garbage > ignore_threshold) && (new_garbage < min_garbage); - - if (add_regardless || (r->garbage() > garbage_threshold)) { - while ((new_cset > max_young_cset) && (unaffiliated_young_regions > 0)) { - unaffiliated_young_regions--; - max_young_cset += region_size_bytes / ShenandoahEvacWaste; + // If this region has free memory and we choose to place it in the collection set, its free memory is no longer + // available to hold promotion results. So we behave as if its free memory is consumed within the promotion reserve. + size_t anticipated_loss_from_promo_reserve = r->free(); + size_t new_promo_consumption = consumed_by_promo + anticipated_loss_from_promo_reserve; + size_t new_promo_reserve = old_promo_reserve; + while ((new_promo_consumption > new_promo_reserve) && (committed_from_shared_reserves < shared_reserves)) { + committed_from_shared_reserves += region_size_bytes; + proposed_old_region_expansion++; + new_promo_reserve += region_size_bytes; + } + if ((new_old_consumption <= new_old_evac_reserve) && (new_promo_consumption <= new_promo_reserve)) { + add_region = true; + old_evac_reserve = new_old_evac_reserve; + old_promo_reserve = new_promo_reserve; + old_evac_bytes += live_bytes; + consumed_by_old_evac = new_old_consumption; + consumed_by_promo = new_promo_consumption; + cur_garbage = new_garbage; + old_regions_evacuated++; + } else { + // We failed to sufficiently expand old so unwind proposed expansion + committed_from_shared_reserves -= proposed_old_region_expansion * region_size_bytes; + } + } else if (heap->is_tenurable(r)) { + size_t anticipated_consumption = (size_t) (live_bytes * ShenandoahPromoEvacWaste); + size_t new_promo_consumption = consumed_by_promo + anticipated_consumption; + size_t new_promo_reserve = old_promo_reserve; + size_t proposed_old_region_expansion = 0; + while ((new_promo_consumption > new_promo_reserve) && (committed_from_shared_reserves < shared_reserves)) { + committed_from_shared_reserves += region_size_bytes; + proposed_old_region_expansion++; + new_promo_reserve += region_size_bytes; + } + if (new_promo_consumption <= new_promo_reserve) { + add_region = true; + old_promo_reserve = new_promo_reserve; + promo_bytes += live_bytes; + consumed_by_promo = new_promo_consumption; + cur_garbage = new_garbage; + aged_regions_promoted++; + } else { + // We failed to sufficiently expand old so unwind proposed expansion + committed_from_shared_reserves -= proposed_old_region_expansion * region_size_bytes; + } + } else { + assert(r->is_young() && !heap->is_tenurable(r), "DeMorgan's law (assuming r->is_affiliated)"); + size_t anticipated_consumption = (size_t) (live_bytes * ShenandoahEvacWaste); + size_t new_young_evac_consumption = consumed_by_young_evac + anticipated_consumption; + size_t new_young_evac_reserve = young_evac_reserve; + size_t proposed_young_region_expansion = 0; + while ((new_young_evac_consumption > new_young_evac_reserve) && (committed_from_shared_reserves < shared_reserves)) { + committed_from_shared_reserves += region_size_bytes; + proposed_young_region_expansion++; + new_young_evac_reserve += region_size_bytes; + } + if (new_young_evac_consumption <= new_young_evac_reserve) { + add_region = true; + young_evac_reserve = new_young_evac_reserve; + young_evac_bytes += live_bytes; + consumed_by_young_evac = new_young_evac_consumption; + cur_garbage = new_garbage; + young_regions_evacuated++; + } else { + // We failed to sufficiently expand old so unwind proposed expansion + committed_from_shared_reserves -= proposed_young_region_expansion * region_size_bytes; } - } - if ((new_cset <= max_young_cset) && (add_regardless || (region_garbage > garbage_threshold))) { - add_region = true; - young_cur_cset = new_cset; - cur_young_garbage = new_garbage; } } if (add_region) { cset->add_region(r); } } - if (regions_transferred_to_old > 0) { - assert(young_evac_reserve > regions_transferred_to_old * region_size_bytes, "young reserve cannot be negative"); - heap->young_generation()->set_evacuation_reserve(young_evac_reserve - regions_transferred_to_old * region_size_bytes); - heap->old_generation()->set_evacuation_reserve(old_evac_reserve + regions_transferred_to_old * region_size_bytes); + + if (committed_from_shared_reserves < shared_reserves) { + // Give all the rest to promotion + old_promo_reserve += (shared_reserves - committed_from_shared_reserves); + // dead code: committed_from_shared_reserves = shared_reserves; } + + // Consider the effects of round-off: + // 1. We know that the sum over each evacuation mutiplied by Evacuation Waste is <= total evacuation reserve + // 2. However, the reserve for each individual evacuation may be rounded down. In the worst case, we will be over budget + // by the number of regions evacuated, since each region's reserve might be under-estimated by at most 1 + // 3. Likewise, if we take the sum of bytes evacuated and multiply this by the Evacuation Waste and then round down + // to nearest integer, the calculated reserve will underestimate the true reserve needs by at most 1. + // 4. This explains the adjustments to subtotals in the assert statements below. + assert(young_evac_bytes * ShenandoahEvacWaste <= young_evac_reserve + young_regions_evacuated, + "budget: %zu <= %zu", (size_t) (young_evac_bytes * ShenandoahEvacWaste), young_evac_reserve); + assert(old_evac_bytes * ShenandoahOldEvacWaste <= old_evac_reserve + old_regions_evacuated, + "budget: %zu <= %zu", (size_t) (old_evac_bytes * ShenandoahOldEvacWaste), old_evac_reserve); + assert(promo_bytes * ShenandoahPromoEvacWaste <= old_promo_reserve + aged_regions_promoted, + "budget: %zu <= %zu", (size_t) (promo_bytes * ShenandoahPromoEvacWaste), old_promo_reserve); + assert(young_evac_reserve + old_evac_reserve + old_promo_reserve <= + heap->young_generation()->get_evacuation_reserve() + heap->old_generation()->get_evacuation_reserve() + + heap->old_generation()->get_promoted_reserve(), "Exceeded budget"); + + if (heap->young_generation()->get_evacuation_reserve() < young_evac_reserve) { + size_t delta_bytes = young_evac_reserve - heap->young_generation()->get_evacuation_reserve(); + size_t delta_regions = delta_bytes / region_size_bytes; + size_t regions_to_transfer = MIN2(unaffiliated_old_regions, delta_regions); + log_info(gc)("Global GC moves %zu unaffiliated regions from old collector to young collector reserves", regions_to_transfer); + ssize_t negated_regions = -regions_to_transfer; + heap->free_set()->move_unaffiliated_regions_from_collector_to_old_collector(negated_regions); + } else if (heap->young_generation()->get_evacuation_reserve() > young_evac_reserve) { + size_t delta_bytes = heap->young_generation()->get_evacuation_reserve() - young_evac_reserve; + size_t delta_regions = delta_bytes / region_size_bytes; + size_t regions_to_transfer = MIN2(unaffiliated_young_regions, delta_regions); + log_info(gc)("Global GC moves %zu unaffiliated regions from young collector to old collector reserves", regions_to_transfer); + heap->free_set()->move_unaffiliated_regions_from_collector_to_old_collector(regions_to_transfer); + } + + heap->young_generation()->set_evacuation_reserve(young_evac_reserve); + heap->old_generation()->set_evacuation_reserve(old_evac_reserve); + heap->old_generation()->set_promoted_reserve(old_promo_reserve); } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp index 1f95f75c521..e0513f60da9 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp @@ -39,9 +39,9 @@ class ShenandoahGlobalHeuristics : public ShenandoahGenerationalHeuristics { public: ShenandoahGlobalHeuristics(ShenandoahGlobalGeneration* generation); - void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) override; + size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) override; private: void choose_global_collection_set(ShenandoahCollectionSet* cset, diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp index eb740cfac61..aeb64b6f1df 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp @@ -72,7 +72,7 @@ ShenandoahHeuristics::~ShenandoahHeuristics() { FREE_C_HEAP_ARRAY(RegionGarbage, _region_data); } -void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { +size_t ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { ShenandoahHeap* heap = ShenandoahHeap::heap(); assert(collection_set->is_empty(), "Must be empty"); @@ -153,8 +153,8 @@ void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collec if (immediate_percent <= ShenandoahImmediateThreshold) { choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free); } - collection_set->summarize(total_garbage, immediate_garbage, immediate_regions); + return 0; } void ShenandoahHeuristics::record_cycle_start() { diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp index e1139765022..ae34a9743a9 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp @@ -183,9 +183,12 @@ protected: static int compare_by_garbage(RegionData a, RegionData b); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, - RegionData* data, size_t data_size, - size_t free) = 0; + // This is a helper function to choose_collection_set(), returning the number of regions that need to be transferred to + // the old reserve from the young reserve in order to effectively evacuate the chosen collection set. In non-generational + // mode, the return value is 0. + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, + RegionData* data, size_t data_size, + size_t free) = 0; void adjust_penalty(intx step); @@ -233,7 +236,9 @@ public: virtual void record_requested_gc(); - virtual void choose_collection_set(ShenandoahCollectionSet* collection_set); + // Choose the collection set, returning the number of regions that need to be transferred to the old reserve from the young + // reserve in order to effectively evacuate the chosen collection set. In non-generational mode, the return value is 0. + virtual size_t choose_collection_set(ShenandoahCollectionSet* collection_set); virtual bool can_unload_classes(); diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp index f2c6e427ea8..f47d0cbe819 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp @@ -26,9 +26,11 @@ #include "gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp" #include "gc/shenandoah/shenandoahCollectionSet.hpp" #include "gc/shenandoah/shenandoahCollectorPolicy.hpp" +#include "gc/shenandoah/shenandoahFreeSet.hpp" #include "gc/shenandoah/shenandoahGenerationalHeap.hpp" #include "gc/shenandoah/shenandoahHeapRegion.inline.hpp" #include "gc/shenandoah/shenandoahOldGeneration.hpp" +#include "gc/shenandoah/shenandoahYoungGeneration.hpp" #include "logging/log.hpp" #include "utilities/quickSort.hpp" @@ -77,15 +79,17 @@ ShenandoahOldHeuristics::ShenandoahOldHeuristics(ShenandoahOldGeneration* genera } bool ShenandoahOldHeuristics::prime_collection_set(ShenandoahCollectionSet* collection_set) { - if (unprocessed_old_collection_candidates() == 0) { - return false; - } + _mixed_evac_cset = collection_set; + _included_old_regions = 0; + _evacuated_old_bytes = 0; + _collected_old_bytes = 0; if (_old_generation->is_preparing_for_mark()) { // We have unprocessed old collection candidates, but the heuristic has given up on evacuating them. // This is most likely because they were _all_ pinned at the time of the last mixed evacuation (and // this in turn is most likely because there are just one or two candidate regions remaining). - log_info(gc, ergo)("Remaining " UINT32_FORMAT " old regions are being coalesced and filled", unprocessed_old_collection_candidates()); + log_info(gc, ergo)("Remaining " UINT32_FORMAT + " old regions are being coalesced and filled", unprocessed_old_collection_candidates()); return false; } @@ -111,150 +115,44 @@ bool ShenandoahOldHeuristics::prime_collection_set(ShenandoahCollectionSet* coll // of memory that can still be evacuated. We address this by reducing the evacuation budget by the amount // of live memory in that region and by the amount of unallocated memory in that region if the evacuation // budget is constrained by availability of free memory. - const size_t old_evacuation_reserve = _old_generation->get_evacuation_reserve(); - const size_t old_evacuation_budget = (size_t) ((double) old_evacuation_reserve / ShenandoahOldEvacWaste); - size_t unfragmented_available = _old_generation->free_unaffiliated_regions() * ShenandoahHeapRegion::region_size_bytes(); - size_t fragmented_available; - size_t excess_fragmented_available; + _old_evacuation_reserve = _old_generation->get_evacuation_reserve(); + _old_evacuation_budget = (size_t) ((double) _old_evacuation_reserve / ShenandoahOldEvacWaste); - if (unfragmented_available > old_evacuation_budget) { - unfragmented_available = old_evacuation_budget; - fragmented_available = 0; - excess_fragmented_available = 0; + // fragmented_available is the amount of memory within partially consumed old regions that may be required to + // hold the results of old evacuations. If all of the memory required by the old evacuation reserve is available + // in unfragmented regions (unaffiliated old regions), then fragmented_available is zero because we do not need + // to evacuate into the existing partially consumed old regions. + + // if fragmented_available is non-zero, excess_fragmented_old_budget represents the amount of fragmented memory + // that is available within old, but is not required to hold the resuilts of old evacuation. As old-gen regions + // are added into the collection set, their free memory is subtracted from excess_fragmented_old_budget until the + // excess is exhausted. For old-gen regions subsequently added to the collection set, their free memory is + // subtracted from fragmented_available and from the old_evacuation_budget (since the budget decreases when this + // fragmented_available memory decreases). After fragmented_available has been exhausted, any further old regions + // selected for the cset do not further decrease the old_evacuation_budget because all further evacuation is targeted + // to unfragmented regions. + + size_t unaffiliated_available = _old_generation->free_unaffiliated_regions() * ShenandoahHeapRegion::region_size_bytes(); + if (unaffiliated_available > _old_evacuation_reserve) { + _unspent_unfragmented_old_budget = _old_evacuation_budget; + _unspent_fragmented_old_budget = 0; + _excess_fragmented_old_budget = 0; } else { - assert(_old_generation->available() >= old_evacuation_budget, "Cannot budget more than is available"); - fragmented_available = _old_generation->available() - unfragmented_available; - assert(fragmented_available + unfragmented_available >= old_evacuation_budget, "Budgets do not add up"); - if (fragmented_available + unfragmented_available > old_evacuation_budget) { - excess_fragmented_available = (fragmented_available + unfragmented_available) - old_evacuation_budget; - fragmented_available -= excess_fragmented_available; + assert(_old_generation->available() >= _old_evacuation_reserve, "Cannot reserve more than is available"); + size_t affiliated_available = _old_generation->available() - unaffiliated_available; + assert(affiliated_available + unaffiliated_available >= _old_evacuation_reserve, "Budgets do not add up"); + if (affiliated_available + unaffiliated_available > _old_evacuation_reserve) { + _excess_fragmented_old_budget = (affiliated_available + unaffiliated_available) - _old_evacuation_reserve; + affiliated_available -= _excess_fragmented_old_budget; } + _unspent_fragmented_old_budget = (size_t) ((double) affiliated_available / ShenandoahOldEvacWaste); + _unspent_unfragmented_old_budget = (size_t) ((double) unaffiliated_available / ShenandoahOldEvacWaste); } - size_t remaining_old_evacuation_budget = old_evacuation_budget; - log_debug(gc)("Choose old regions for mixed collection: old evacuation budget: %zu%s, candidates: %u", - byte_size_in_proper_unit(old_evacuation_budget), proper_unit_for_byte_size(old_evacuation_budget), + log_debug(gc)("Choose old regions for mixed collection: old evacuation budget: " PROPERFMT ", candidates: %u", + PROPERFMTARGS(_old_evacuation_budget), unprocessed_old_collection_candidates()); - - size_t lost_evacuation_capacity = 0; - - // The number of old-gen regions that were selected as candidates for collection at the end of the most recent old-gen - // concurrent marking phase and have not yet been collected is represented by unprocessed_old_collection_candidates(). - // Candidate regions are ordered according to increasing amount of live data. If there is not sufficient room to - // evacuate region N, then there is no need to even consider evacuating region N+1. - while (unprocessed_old_collection_candidates() > 0) { - // Old collection candidates are sorted in order of decreasing garbage contained therein. - ShenandoahHeapRegion* r = next_old_collection_candidate(); - if (r == nullptr) { - break; - } - assert(r->is_regular(), "There should be no humongous regions in the set of mixed-evac candidates"); - - // If region r is evacuated to fragmented memory (to free memory within a partially used region), then we need - // to decrease the capacity of the fragmented memory by the scaled loss. - - const size_t live_data_for_evacuation = r->get_live_data_bytes(); - size_t lost_available = r->free(); - - if ((lost_available > 0) && (excess_fragmented_available > 0)) { - if (lost_available < excess_fragmented_available) { - excess_fragmented_available -= lost_available; - lost_evacuation_capacity -= lost_available; - lost_available = 0; - } else { - lost_available -= excess_fragmented_available; - lost_evacuation_capacity -= excess_fragmented_available; - excess_fragmented_available = 0; - } - } - size_t scaled_loss = (size_t) ((double) lost_available / ShenandoahOldEvacWaste); - if ((lost_available > 0) && (fragmented_available > 0)) { - if (scaled_loss + live_data_for_evacuation < fragmented_available) { - fragmented_available -= scaled_loss; - scaled_loss = 0; - } else { - // We will have to allocate this region's evacuation memory from unfragmented memory, so don't bother - // to decrement scaled_loss - } - } - if (scaled_loss > 0) { - // We were not able to account for the lost free memory within fragmented memory, so we need to take this - // allocation out of unfragmented memory. Unfragmented memory does not need to account for loss of free. - if (live_data_for_evacuation > unfragmented_available) { - // There is no room to evacuate this region or any that come after it in within the candidates array. - log_debug(gc, cset)("Not enough unfragmented memory (%zu) to hold evacuees (%zu) from region: (%zu)", - unfragmented_available, live_data_for_evacuation, r->index()); - break; - } else { - unfragmented_available -= live_data_for_evacuation; - } - } else { - // Since scaled_loss == 0, we have accounted for the loss of free memory, so we can allocate from either - // fragmented or unfragmented available memory. Use up the fragmented memory budget first. - size_t evacuation_need = live_data_for_evacuation; - - if (evacuation_need > fragmented_available) { - evacuation_need -= fragmented_available; - fragmented_available = 0; - } else { - fragmented_available -= evacuation_need; - evacuation_need = 0; - } - if (evacuation_need > unfragmented_available) { - // There is no room to evacuate this region or any that come after it in within the candidates array. - log_debug(gc, cset)("Not enough unfragmented memory (%zu) to hold evacuees (%zu) from region: (%zu)", - unfragmented_available, live_data_for_evacuation, r->index()); - break; - } else { - unfragmented_available -= evacuation_need; - // dead code: evacuation_need == 0; - } - } - collection_set->add_region(r); - included_old_regions++; - evacuated_old_bytes += live_data_for_evacuation; - collected_old_bytes += r->garbage(); - consume_old_collection_candidate(); - } - - if (_first_pinned_candidate != NOT_FOUND) { - // Need to deal with pinned regions - slide_pinned_regions_to_front(); - } - decrease_unprocessed_old_collection_candidates_live_memory(evacuated_old_bytes); - if (included_old_regions > 0) { - log_info(gc, ergo)("Old-gen piggyback evac (" UINT32_FORMAT " regions, evacuating " PROPERFMT ", reclaiming: " PROPERFMT ")", - included_old_regions, PROPERFMTARGS(evacuated_old_bytes), PROPERFMTARGS(collected_old_bytes)); - } - - if (unprocessed_old_collection_candidates() == 0) { - // We have added the last of our collection candidates to a mixed collection. - // Any triggers that occurred during mixed evacuations may no longer be valid. They can retrigger if appropriate. - clear_triggers(); - - _old_generation->complete_mixed_evacuations(); - } else if (included_old_regions == 0) { - // We have candidates, but none were included for evacuation - are they all pinned? - // or did we just not have enough room for any of them in this collection set? - // We don't want a region with a stuck pin to prevent subsequent old collections, so - // if they are all pinned we transition to a state that will allow us to make these uncollected - // (pinned) regions parsable. - if (all_candidates_are_pinned()) { - log_info(gc, ergo)("All candidate regions " UINT32_FORMAT " are pinned", unprocessed_old_collection_candidates()); - _old_generation->abandon_mixed_evacuations(); - } else { - log_info(gc, ergo)("No regions selected for mixed collection. " - "Old evacuation budget: " PROPERFMT ", Remaining evacuation budget: " PROPERFMT - ", Lost capacity: " PROPERFMT - ", Next candidate: " UINT32_FORMAT ", Last candidate: " UINT32_FORMAT, - PROPERFMTARGS(old_evacuation_reserve), - PROPERFMTARGS(remaining_old_evacuation_budget), - PROPERFMTARGS(lost_evacuation_capacity), - _next_old_collection_candidate, _last_old_collection_candidate); - } - } - - return (included_old_regions > 0); + return add_old_regions_to_cset(); } bool ShenandoahOldHeuristics::all_candidates_are_pinned() { @@ -328,6 +226,187 @@ void ShenandoahOldHeuristics::slide_pinned_regions_to_front() { _next_old_collection_candidate = write_index + 1; } +bool ShenandoahOldHeuristics::add_old_regions_to_cset() { + if (unprocessed_old_collection_candidates() == 0) { + return false; + } + _first_pinned_candidate = NOT_FOUND; + + // The number of old-gen regions that were selected as candidates for collection at the end of the most recent old-gen + // concurrent marking phase and have not yet been collected is represented by unprocessed_old_collection_candidates(). + // Candidate regions are ordered according to increasing amount of live data. If there is not sufficient room to + // evacuate region N, then there is no need to even consider evacuating region N+1. + while (unprocessed_old_collection_candidates() > 0) { + // Old collection candidates are sorted in order of decreasing garbage contained therein. + ShenandoahHeapRegion* r = next_old_collection_candidate(); + if (r == nullptr) { + break; + } + assert(r->is_regular(), "There should be no humongous regions in the set of mixed-evac candidates"); + + // If region r is evacuated to fragmented memory (to free memory within a partially used region), then we need + // to decrease the capacity of the fragmented memory by the scaled loss. + + const size_t live_data_for_evacuation = r->get_live_data_bytes(); + size_t lost_available = r->free(); + + ssize_t fragmented_delta = 0; + ssize_t unfragmented_delta = 0; + ssize_t excess_delta = 0; + + // We must decrease our mixed-evacuation budgets proportional to the lost available memory. This memory that is no + // longer available was likely "promised" to promotions, so we must decrease our mixed evacuations now. + // (e.g. if we loose 14 bytes of available old memory, we must decrease the evacuation budget by 10 bytes.) + size_t scaled_loss = (size_t) (((double) lost_available) / ShenandoahOldEvacWaste); + if (lost_available > 0) { + // We need to subtract lost_available from our working evacuation budgets + if (scaled_loss < _excess_fragmented_old_budget) { + excess_delta -= scaled_loss; + _excess_fragmented_old_budget -= scaled_loss; + } else { + excess_delta -= _excess_fragmented_old_budget; + _excess_fragmented_old_budget = 0; + } + + if (scaled_loss < _unspent_fragmented_old_budget) { + _unspent_fragmented_old_budget -= scaled_loss; + fragmented_delta = -scaled_loss; + scaled_loss = 0; + } else { + scaled_loss -= _unspent_fragmented_old_budget; + fragmented_delta = -_unspent_fragmented_old_budget; + _unspent_fragmented_old_budget = 0; + } + + if (scaled_loss < _unspent_unfragmented_old_budget) { + _unspent_unfragmented_old_budget -= scaled_loss; + unfragmented_delta = -scaled_loss; + scaled_loss = 0; + } else { + scaled_loss -= _unspent_unfragmented_old_budget; + fragmented_delta = -_unspent_unfragmented_old_budget; + _unspent_unfragmented_old_budget = 0; + } + } + + // Allocate replica from unfragmented memory if that exists + size_t evacuation_need = live_data_for_evacuation; + if (evacuation_need < _unspent_unfragmented_old_budget) { + _unspent_unfragmented_old_budget -= evacuation_need; + } else { + if (_unspent_unfragmented_old_budget > 0) { + evacuation_need -= _unspent_unfragmented_old_budget; + unfragmented_delta -= _unspent_unfragmented_old_budget; + _unspent_unfragmented_old_budget = 0; + } + // Take the remaining allocation out of fragmented available + if (_unspent_fragmented_old_budget > evacuation_need) { + _unspent_fragmented_old_budget -= evacuation_need; + } else { + // We cannot add this region into the collection set. We're done. Undo the adjustments to available. + _unspent_fragmented_old_budget -= fragmented_delta; + _unspent_unfragmented_old_budget -= unfragmented_delta; + _excess_fragmented_old_budget -= excess_delta; + break; + } + } + _mixed_evac_cset->add_region(r); + _included_old_regions++; + _evacuated_old_bytes += live_data_for_evacuation; + _collected_old_bytes += r->garbage(); + consume_old_collection_candidate(); + } + return true; +} + +bool ShenandoahOldHeuristics::finalize_mixed_evacs() { + if (_first_pinned_candidate != NOT_FOUND) { + // Need to deal with pinned regions + slide_pinned_regions_to_front(); + } + decrease_unprocessed_old_collection_candidates_live_memory(_evacuated_old_bytes); + if (_included_old_regions > 0) { + log_info(gc)("Old-gen mixed evac (%zu regions, evacuating %zu%s, reclaiming: %zu%s)", + _included_old_regions, + byte_size_in_proper_unit(_evacuated_old_bytes), proper_unit_for_byte_size(_evacuated_old_bytes), + byte_size_in_proper_unit(_collected_old_bytes), proper_unit_for_byte_size(_collected_old_bytes)); + } + + if (unprocessed_old_collection_candidates() == 0) { + // We have added the last of our collection candidates to a mixed collection. + // Any triggers that occurred during mixed evacuations may no longer be valid. They can retrigger if appropriate. + clear_triggers(); + _old_generation->complete_mixed_evacuations(); + } else if (_included_old_regions == 0) { + // We have candidates, but none were included for evacuation - are they all pinned? + // or did we just not have enough room for any of them in this collection set? + // We don't want a region with a stuck pin to prevent subsequent old collections, so + // if they are all pinned we transition to a state that will allow us to make these uncollected + // (pinned) regions parsable. + if (all_candidates_are_pinned()) { + log_info(gc)("All candidate regions " UINT32_FORMAT " are pinned", unprocessed_old_collection_candidates()); + _old_generation->abandon_mixed_evacuations(); + } else { + log_info(gc)("No regions selected for mixed collection. " + "Old evacuation budget: " PROPERFMT ", Next candidate: " UINT32_FORMAT ", Last candidate: " UINT32_FORMAT, + PROPERFMTARGS(_old_evacuation_reserve), + _next_old_collection_candidate, _last_old_collection_candidate); + } + } + return (_included_old_regions > 0); +} + +bool ShenandoahOldHeuristics::top_off_collection_set(size_t &add_regions_to_old) { + if (unprocessed_old_collection_candidates() == 0) { + add_regions_to_old = 0; + return false; + } else { + ShenandoahYoungGeneration* young_generation = _heap->young_generation(); + size_t young_unaffiliated_regions = young_generation->free_unaffiliated_regions(); + size_t max_young_cset = young_generation->get_evacuation_reserve(); + + // We have budgeted to assure the live_bytes_in_tenurable_regions() get evacuated into old generation. Young reserves + // only for untenurable region evacuations. + size_t planned_young_evac = _mixed_evac_cset->get_live_bytes_in_untenurable_regions(); + size_t consumed_from_young_cset = (size_t) (planned_young_evac * ShenandoahEvacWaste); + + size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes(); + size_t regions_required_for_collector_reserve = (consumed_from_young_cset + region_size_bytes - 1) / region_size_bytes; + + assert(consumed_from_young_cset <= max_young_cset, "sanity"); + assert(max_young_cset <= young_unaffiliated_regions * region_size_bytes, "sanity"); + + size_t regions_for_old_expansion; + if (consumed_from_young_cset < max_young_cset) { + size_t excess_young_reserves = max_young_cset - consumed_from_young_cset; + // We can only transfer empty regions from young to old. Furthermore, we must be careful to assure that the young + // Collector reserve that remains after transfer is comprised entirely of empty (unaffiliated) regions. + size_t consumed_unaffiliated_regions = (consumed_from_young_cset + region_size_bytes - 1) / region_size_bytes; + size_t available_unaffiliated_regions = ((young_unaffiliated_regions > consumed_unaffiliated_regions)? + young_unaffiliated_regions - consumed_unaffiliated_regions: 0); + regions_for_old_expansion = MIN2(available_unaffiliated_regions, excess_young_reserves / region_size_bytes); + } else { + regions_for_old_expansion = 0; + } + if (regions_for_old_expansion > 0) { + log_info(gc)("Augmenting old-gen evacuation budget from unexpended young-generation reserve by %zu regions", + regions_for_old_expansion); + add_regions_to_old = regions_for_old_expansion; + size_t budget_supplement = region_size_bytes * regions_for_old_expansion; + size_t supplement_without_waste = (size_t) (((double) budget_supplement) / ShenandoahOldEvacWaste); + _old_evacuation_budget += supplement_without_waste; + _unspent_unfragmented_old_budget += supplement_without_waste; + _old_generation->augment_evacuation_reserve(budget_supplement); + young_generation->set_evacuation_reserve(max_young_cset - budget_supplement); + + return add_old_regions_to_cset(); + } else { + add_regions_to_old = 0; + return false; + } + } +} + void ShenandoahOldHeuristics::prepare_for_old_collections() { ShenandoahHeap* heap = ShenandoahHeap::heap(); @@ -336,7 +415,6 @@ void ShenandoahOldHeuristics::prepare_for_old_collections() { size_t immediate_garbage = 0; size_t immediate_regions = 0; size_t live_data = 0; - RegionData* candidates = _region_data; for (size_t i = 0; i < num_regions; i++) { ShenandoahHeapRegion* region = heap->get_region(i); @@ -355,10 +433,10 @@ void ShenandoahOldHeuristics::prepare_for_old_collections() { // else, regions that were promoted in place had 0 old live data at mark start if (region->is_regular() || region->is_regular_pinned()) { - // Only place regular or pinned regions with live data into the candidate set. - // Pinned regions cannot be evacuated, but we are not actually choosing candidates - // for the collection set here. That happens later during the next young GC cycle, - // by which time, the pinned region may no longer be pinned. + // Only place regular or pinned regions with live data into the candidate set. + // Pinned regions cannot be evacuated, but we are not actually choosing candidates + // for the collection set here. That happens later during the next young GC cycle, + // by which time, the pinned region may no longer be pinned. if (!region->has_live()) { assert(!region->is_pinned(), "Pinned region should have live (pinned) objects."); region->make_trash_immediate(); @@ -561,6 +639,7 @@ unsigned int ShenandoahOldHeuristics::get_coalesce_and_fill_candidates(Shenandoa void ShenandoahOldHeuristics::abandon_collection_candidates() { _last_old_collection_candidate = 0; _next_old_collection_candidate = 0; + _live_bytes_in_unprocessed_candidates = 0; _last_old_region = 0; } @@ -805,8 +884,9 @@ bool ShenandoahOldHeuristics::is_experimental() { return true; } -void ShenandoahOldHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, - ShenandoahHeuristics::RegionData* data, - size_t data_size, size_t free) { +size_t ShenandoahOldHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, + ShenandoahHeuristics::RegionData* data, + size_t data_size, size_t free) { ShouldNotReachHere(); + return 0; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp index f38194c1ee7..97a5b1ebf24 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp @@ -102,6 +102,30 @@ private: size_t _fragmentation_first_old_region; size_t _fragmentation_last_old_region; + // State variables involved in construction of a mixed-evacuation collection set. These variables are initialized + // when client code invokes prime_collection_set(). They are consulted, and sometimes modified, when client code + // calls top_off_collection_set() to possibly expand the number of old-gen regions in a mixed evacuation cset, and by + // finalize_mixed_evacs(), which prepares the way for mixed evacuations to begin. + ShenandoahCollectionSet* _mixed_evac_cset; + size_t _evacuated_old_bytes; + size_t _collected_old_bytes; + size_t _included_old_regions; + size_t _old_evacuation_reserve; + size_t _old_evacuation_budget; + + // This represents the amount of memory that can be evacuated from old into initially empty regions during a mixed evacuation. + // This is the total amount of unfragmented free memory in old divided by ShenandoahOldEvacWaste. + size_t _unspent_unfragmented_old_budget; + + // This represents the amount of memory that can be evacuated from old into initially non-empty regions during a mixed + // evacuation. This is the total amount of initially fragmented free memory in old divided by ShenandoahOldEvacWaste. + size_t _unspent_fragmented_old_budget; + + // If there is more available memory in old than is required by the intended mixed evacuation, the amount of excess + // memory is represented by _excess_fragmented_old. To convert this value into a promotion budget, multiply by + // ShenandoahOldEvacWaste and divide by ShenandoahPromoWaste. + size_t _excess_fragmented_old_budget; + // The value of command-line argument ShenandoahOldGarbageThreshold represents the percent of garbage that must // be present within an old-generation region before that region is considered a good candidate for inclusion in // the collection set under normal circumstances. For our purposes, normal circustances are when the memory consumed @@ -131,7 +155,15 @@ private: void set_trigger_if_old_is_overgrown(); protected: - void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, RegionData* data, size_t data_size, size_t free) override; + size_t + choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, RegionData* data, size_t data_size, size_t free) override; + + // This internal helper routine adds as many mixed evacuation candidate regions as fit within the old-gen evacuation budget + // to the collection set. This may be called twice to prepare for any given mixed evacuation cycle, the first time with + // a conservative old evacuation budget, and the second time with a larger more aggressive old evacuation budget. Returns + // true iff we need to finalize mixed evacs. (If no regions are added to the collection set, there is no need to finalize + // mixed evacuations.) + bool add_old_regions_to_cset(); public: explicit ShenandoahOldHeuristics(ShenandoahOldGeneration* generation, ShenandoahGenerationalHeap* gen_heap); @@ -139,8 +171,22 @@ public: // Prepare for evacuation of old-gen regions by capturing the mark results of a recently completed concurrent mark pass. void prepare_for_old_collections(); - // Return true iff the collection set is primed with at least one old-gen region. - bool prime_collection_set(ShenandoahCollectionSet* set); + // Initialize instance variables to support the preparation of a mixed-evacuation collection set. Adds as many + // old candidate regions into the collection set as can fit within the iniital conservative old evacuation budget. + // Returns true iff we need to finalize mixed evacs. + bool prime_collection_set(ShenandoahCollectionSet* collection_set); + + // If young evacuation did not consume all of its available evacuation reserve, add as many additional mixed- + // evacuation candidate regions into the collection set as will fit within this excess repurposed reserved. + // Returns true iff we need to finalize mixed evacs. Upon return, the var parameter regions_to_xfer holds the + // number of regions to transfer from young to old. + bool top_off_collection_set(size_t &add_regions_to_old); + + // Having added all eligible mixed-evacuation candidates to the collection set, this function updates the total count + // of how much old-gen memory remains to be evacuated and adjusts the representation of old-gen regions that remain to + // be evacuated, giving special attention to regions that are currently pinned. It outputs relevant log messages and + // returns true iff the collection set holds at least one unpinned mixed evacuation candidate. + bool finalize_mixed_evacs(); // How many old-collection candidates have not yet been processed? uint unprocessed_old_collection_candidates() const; diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp index b5e9cc433ea..d4a38278161 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp @@ -50,9 +50,9 @@ bool ShenandoahPassiveHeuristics::should_degenerate_cycle() { return ShenandoahDegeneratedGC; } -void ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) { +size_t ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) { assert(ShenandoahDegeneratedGC, "This path is only taken for Degenerated GC"); // Do not select too large CSet that would overflow the available free space. @@ -76,4 +76,5 @@ void ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(Shenando cset->add_region(r); } } + return 0; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp index be4e91b1800..7a64fad7cc9 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp @@ -46,9 +46,9 @@ public: virtual bool should_degenerate_cycle(); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, - RegionData* data, size_t data_size, - size_t free); + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, + RegionData* data, size_t data_size, + size_t free); virtual const char* name() { return "Passive"; } virtual bool is_diagnostic() { return true; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp index d4d66fef6a1..3843e434781 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp @@ -59,9 +59,9 @@ bool ShenandoahStaticHeuristics::should_start_gc() { return ShenandoahHeuristics::should_start_gc(); } -void ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t free) { +size_t ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t free) { size_t threshold = ShenandoahHeapRegion::region_size_bytes() * ShenandoahGarbageThreshold / 100; for (size_t idx = 0; idx < size; idx++) { @@ -70,4 +70,5 @@ void ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(Shenandoa cset->add_region(r); } } + return 0; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp index 24cb5547921..27dc3c8e0ae 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp @@ -40,9 +40,9 @@ public: virtual bool should_start_gc(); - virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t free); + virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t free); virtual const char* name() { return "Static"; } virtual bool is_diagnostic() { return false; } diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp index 15d1058d7cd..01c3873df72 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp @@ -33,11 +33,11 @@ #include "utilities/quickSort.hpp" ShenandoahYoungHeuristics::ShenandoahYoungHeuristics(ShenandoahYoungGeneration* generation) - : ShenandoahGenerationalHeuristics(generation) { + : ShenandoahGenerationalHeuristics(generation) { } -void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, +size_t ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, RegionData* data, size_t size, size_t actual_free) { // See comments in ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(): @@ -48,6 +48,8 @@ void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenandoah // array before younger regions that typically contain more garbage. This is one reason why, // for example, we continue examining regions even after rejecting a region that has // more live data than we can evacuate. + ShenandoahGenerationalHeap* heap = ShenandoahGenerationalHeap::heap(); + bool need_to_finalize_mixed = heap->old_generation()->heuristics()->prime_collection_set(cset); // Better select garbage-first regions QuickSort::sort(data, (int) size, compare_by_garbage); @@ -55,6 +57,17 @@ void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenandoah size_t cur_young_garbage = add_preselected_regions_to_collection_set(cset, data, size); choose_young_collection_set(cset, data, size, actual_free, cur_young_garbage); + + // Especially when young-gen trigger is expedited in order to finish mixed evacuations, there may not be + // enough consolidated garbage to make effective use of young-gen evacuation reserve. If there is still + // young-gen reserve available following selection of the young-gen collection set, see if we can use + // this memory to expand the old-gen evacuation collection set. + size_t add_regions_to_old; + need_to_finalize_mixed |= heap->old_generation()->heuristics()->top_off_collection_set(add_regions_to_old); + if (need_to_finalize_mixed) { + heap->old_generation()->heuristics()->finalize_mixed_evacs(); + } + return add_regions_to_old; } void ShenandoahYoungHeuristics::choose_young_collection_set(ShenandoahCollectionSet* cset, diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp index b9d64059680..85587887663 100644 --- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp +++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp @@ -38,9 +38,9 @@ public: explicit ShenandoahYoungHeuristics(ShenandoahYoungGeneration* generation); - void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, - RegionData* data, size_t size, - size_t actual_free) override; + size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset, + RegionData* data, size_t size, + size_t actual_free) override; bool should_start_gc() override; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.cpp b/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.cpp index e58a7f40796..c1c6b876d90 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.cpp @@ -50,6 +50,8 @@ ShenandoahCollectionSet::ShenandoahCollectionSet(ShenandoahHeap* heap, ReservedS _region_count(0), _old_garbage(0), _preselected_regions(nullptr), + _young_available_bytes_collected(0), + _old_available_bytes_collected(0), _current_index(0) { // The collection set map is reserved to cover the entire heap *and* zero addresses. @@ -104,6 +106,7 @@ void ShenandoahCollectionSet::add_region(ShenandoahHeapRegion* r) { } } else if (r->is_old()) { _old_bytes_to_evacuate += live; + _old_available_bytes_collected += free; _old_garbage += garbage; } @@ -140,6 +143,7 @@ void ShenandoahCollectionSet::clear() { _old_bytes_to_evacuate = 0; _young_available_bytes_collected = 0; + _old_available_bytes_collected = 0; _has_old_regions = false; } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.hpp index a1b77baa2d3..c99271de1fb 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.hpp @@ -75,6 +75,10 @@ private: // should be subtracted from what's available. size_t _young_available_bytes_collected; + // When a region having memory available to be allocated is added to the collection set, the region's available memory + // should be subtracted from what's available. + size_t _old_available_bytes_collected; + shenandoah_padding(0); volatile size_t _current_index; shenandoah_padding(1); @@ -121,6 +125,9 @@ public: // Returns the amount of free bytes in young regions in the collection set. size_t get_young_available_bytes_collected() const { return _young_available_bytes_collected; } + // Returns the amount of free bytes in old regions in the collection set. + size_t get_old_available_bytes_collected() const { return _old_available_bytes_collected; } + // Returns the amount of garbage in old regions in the collection set. inline size_t get_old_garbage() const; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp index cee8727a3f4..364279deafe 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp @@ -204,9 +204,8 @@ bool ShenandoahConcurrentGC::collect(GCCause::Cause cause) { return false; } - entry_concurrent_update_refs_prepare(heap); - // Perform update-refs phase. + entry_concurrent_update_refs_prepare(heap); if (ShenandoahVerify) { vmop_entry_init_update_refs(); } @@ -227,6 +226,7 @@ bool ShenandoahConcurrentGC::collect(GCCause::Cause cause) { // Update references freed up collection set, kick the cleanup to reclaim the space. entry_cleanup_complete(); } else { + _abbreviated = true; if (!entry_final_roots()) { assert(_degen_point != _degenerated_unset, "Need to know where to start degenerated cycle"); return false; @@ -235,7 +235,6 @@ bool ShenandoahConcurrentGC::collect(GCCause::Cause cause) { if (VerifyAfterGC) { vmop_entry_verify_final_roots(); } - _abbreviated = true; } // We defer generation resizing actions until after cset regions have been recycled. We do this even following an @@ -282,7 +281,6 @@ bool ShenandoahConcurrentGC::complete_abbreviated_cycle() { return true; } - void ShenandoahConcurrentGC::vmop_entry_init_mark() { ShenandoahHeap* const heap = ShenandoahHeap::heap(); TraceCollectorStats tcs(heap->monitoring_support()->stw_collection_counters()); @@ -536,6 +534,12 @@ void ShenandoahConcurrentGC::entry_cleanup_early() { // This phase does not use workers, no need for setup heap->try_inject_alloc_failure(); op_cleanup_early(); + if (!heap->is_evacuation_in_progress()) { + // This is an abbreviated cycle. Rebuild the freeset in order to establish reserves for the next GC cycle. Doing + // the rebuild ASAP also expedites availability of immediate trash, reducing the likelihood that we will degenerate + // during promote-in-place processing. + heap->rebuild_free_set(true /*concurrent*/); + } } void ShenandoahConcurrentGC::entry_evacuate() { diff --git a/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.cpp b/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.cpp index a8c97801824..c4fe9103fcb 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.cpp @@ -326,7 +326,7 @@ void ShenandoahRegionPartitions::initialize_old_collector() { } void ShenandoahRegionPartitions::make_all_regions_unavailable() { - shenandoah_assert_heaplocked(); + shenandoah_assert_heaplocked_or_safepoint(); for (size_t partition_id = 0; partition_id < IntNumPartitions; partition_id++) { _membership[partition_id].clear_all(); _leftmosts[partition_id] = _max; @@ -439,6 +439,13 @@ void ShenandoahRegionPartitions::set_capacity_of(ShenandoahFreeSetPartitionId wh _available[int(which_partition)] = value - _used[int(which_partition)]; } +void ShenandoahRegionPartitions::set_used_by(ShenandoahFreeSetPartitionId which_partition, size_t value) { + shenandoah_assert_heaplocked(); + assert (which_partition < NumPartitions, "selected free set must be valid"); + _used[int(which_partition)] = value; + _available[int(which_partition)] = _capacity[int(which_partition)] - value; +} + void ShenandoahRegionPartitions::increase_capacity(ShenandoahFreeSetPartitionId which_partition, size_t bytes) { shenandoah_assert_heaplocked(); @@ -900,7 +907,7 @@ idx_t ShenandoahRegionPartitions::rightmost_empty(ShenandoahFreeSetPartitionId w #ifdef ASSERT -void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { +void ShenandoahRegionPartitions::assert_bounds() { size_t capacities[UIntNumPartitions]; size_t used[UIntNumPartitions]; @@ -936,7 +943,7 @@ void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { switch (partition) { case ShenandoahFreeSetPartitionId::NotFree: { - assert(!validate_totals || (capacity != _region_size_bytes), "Should not be retired if empty"); + assert(capacity != _region_size_bytes, "Should not be retired if empty"); ShenandoahHeapRegion* r = ShenandoahHeap::heap()->get_region(i); if (r->is_humongous()) { if (r->is_old()) { @@ -976,12 +983,12 @@ void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { case ShenandoahFreeSetPartitionId::Collector: case ShenandoahFreeSetPartitionId::OldCollector: { + ShenandoahHeapRegion* r = ShenandoahHeap::heap()->get_region(i); assert(capacity > 0, "free regions must have allocation capacity"); bool is_empty = (capacity == _region_size_bytes); regions[int(partition)]++; used[int(partition)] += _region_size_bytes - capacity; capacities[int(partition)] += _region_size_bytes; - if (i < leftmosts[int(partition)]) { leftmosts[int(partition)] = i; } @@ -1020,20 +1027,20 @@ void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { idx_t beg_off = leftmosts[int(ShenandoahFreeSetPartitionId::Mutator)]; idx_t end_off = rightmosts[int(ShenandoahFreeSetPartitionId::Mutator)]; assert (beg_off >= leftmost(ShenandoahFreeSetPartitionId::Mutator), - "Mutator free regions before the leftmost: %zd, bound %zd", + "Mutator free region before the leftmost: %zd, bound %zd", beg_off, leftmost(ShenandoahFreeSetPartitionId::Mutator)); assert (end_off <= rightmost(ShenandoahFreeSetPartitionId::Mutator), - "Mutator free regions past the rightmost: %zd, bound %zd", + "Mutator free region past the rightmost: %zd, bound %zd", end_off, rightmost(ShenandoahFreeSetPartitionId::Mutator)); beg_off = empty_leftmosts[int(ShenandoahFreeSetPartitionId::Mutator)]; end_off = empty_rightmosts[int(ShenandoahFreeSetPartitionId::Mutator)]; - assert (beg_off >= leftmost_empty(ShenandoahFreeSetPartitionId::Mutator), - "Mutator free empty regions before the leftmost: %zd, bound %zd", - beg_off, leftmost_empty(ShenandoahFreeSetPartitionId::Mutator)); - assert (end_off <= rightmost_empty(ShenandoahFreeSetPartitionId::Mutator), - "Mutator free empty regions past the rightmost: %zd, bound %zd", - end_off, rightmost_empty(ShenandoahFreeSetPartitionId::Mutator)); + assert (beg_off >= _leftmosts_empty[int(ShenandoahFreeSetPartitionId::Mutator)], + "free empty region (%zd) before the leftmost bound %zd", + beg_off, _leftmosts_empty[int(ShenandoahFreeSetPartitionId::Mutator)]); + assert (end_off <= _rightmosts_empty[int(ShenandoahFreeSetPartitionId::Mutator)], + "free empty region (%zd) past the rightmost bound %zd", + end_off, _rightmosts_empty[int(ShenandoahFreeSetPartitionId::Mutator)]); // Performance invariants. Failing these would not break the free partition, but performance would suffer. assert (leftmost(ShenandoahFreeSetPartitionId::Collector) <= _max, "leftmost in bounds: %zd < %zd", @@ -1053,20 +1060,20 @@ void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { beg_off = leftmosts[int(ShenandoahFreeSetPartitionId::Collector)]; end_off = rightmosts[int(ShenandoahFreeSetPartitionId::Collector)]; assert (beg_off >= leftmost(ShenandoahFreeSetPartitionId::Collector), - "Collector free regions before the leftmost: %zd, bound %zd", + "Collector free region before the leftmost: %zd, bound %zd", beg_off, leftmost(ShenandoahFreeSetPartitionId::Collector)); assert (end_off <= rightmost(ShenandoahFreeSetPartitionId::Collector), - "Collector free regions past the rightmost: %zd, bound %zd", + "Collector free region past the rightmost: %zd, bound %zd", end_off, rightmost(ShenandoahFreeSetPartitionId::Collector)); beg_off = empty_leftmosts[int(ShenandoahFreeSetPartitionId::Collector)]; end_off = empty_rightmosts[int(ShenandoahFreeSetPartitionId::Collector)]; assert (beg_off >= _leftmosts_empty[int(ShenandoahFreeSetPartitionId::Collector)], - "Collector free empty regions before the leftmost: %zd, bound %zd", - beg_off, leftmost_empty(ShenandoahFreeSetPartitionId::Collector)); + "Collector free empty region before the leftmost: %zd, bound %zd", + beg_off, _leftmosts_empty[int(ShenandoahFreeSetPartitionId::Collector)]); assert (end_off <= _rightmosts_empty[int(ShenandoahFreeSetPartitionId::Collector)], - "Collector free empty regions past the rightmost: %zd, bound %zd", - end_off, rightmost_empty(ShenandoahFreeSetPartitionId::Collector)); + "Collector free empty region past the rightmost: %zd, bound %zd", + end_off, _rightmosts_empty[int(ShenandoahFreeSetPartitionId::Collector)]); // Performance invariants. Failing these would not break the free partition, but performance would suffer. assert (leftmost(ShenandoahFreeSetPartitionId::OldCollector) <= _max, "OldCollector leftmost in bounds: %zd < %zd", @@ -1083,106 +1090,109 @@ void ShenandoahRegionPartitions::assert_bounds(bool validate_totals) { ShenandoahFreeSetPartitionId::OldCollector), "OldCollector rightmost region should be free: %zd", rightmost(ShenandoahFreeSetPartitionId::OldCollector)); + // Concurrent recycling of trash recycles a region (changing its state from is_trash to is_empty without the heap lock), + // If OldCollector partition is empty, leftmosts will both equal max, rightmosts will both equal zero. // Likewise for empty region partitions. beg_off = leftmosts[int(ShenandoahFreeSetPartitionId::OldCollector)]; end_off = rightmosts[int(ShenandoahFreeSetPartitionId::OldCollector)]; - assert (beg_off >= leftmost(ShenandoahFreeSetPartitionId::OldCollector), - "OldCollector free regions before the leftmost: %zd, bound %zd", + assert (beg_off >= leftmost(ShenandoahFreeSetPartitionId::OldCollector), "free regions before the leftmost: %zd, bound %zd", beg_off, leftmost(ShenandoahFreeSetPartitionId::OldCollector)); - assert (end_off <= rightmost(ShenandoahFreeSetPartitionId::OldCollector), - "OldCollector free regions past the rightmost: %zd, bound %zd", + assert (end_off <= rightmost(ShenandoahFreeSetPartitionId::OldCollector), "free regions past the rightmost: %zd, bound %zd", end_off, rightmost(ShenandoahFreeSetPartitionId::OldCollector)); beg_off = empty_leftmosts[int(ShenandoahFreeSetPartitionId::OldCollector)]; end_off = empty_rightmosts[int(ShenandoahFreeSetPartitionId::OldCollector)]; assert (beg_off >= _leftmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)], - "OldCollector free empty regions before the leftmost: %zd, bound %zd", - beg_off, leftmost_empty(ShenandoahFreeSetPartitionId::OldCollector)); + "free empty region (%zd) before the leftmost bound %zd, region %s trash", + beg_off, _leftmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)], + ((beg_off >= _max)? "out of bounds is not": + (ShenandoahHeap::heap()->get_region(_leftmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)])->is_trash()? + "is": "is not"))); assert (end_off <= _rightmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)], - "OldCollector free empty regions past the rightmost: %zd, bound %zd", - end_off, rightmost_empty(ShenandoahFreeSetPartitionId::OldCollector)); + "free empty region (%zd) past the rightmost bound %zd, region %s trash", + end_off, _rightmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)], + ((end_off < 0)? "out of bounds is not" : + (ShenandoahHeap::heap()->get_region(_rightmosts_empty[int(ShenandoahFreeSetPartitionId::OldCollector)])->is_trash()? + "is": "is not"))); - if (validate_totals) { - // young_retired_regions need to be added to either Mutator or Collector partitions, 100% used. - // Give enough of young_retired_regions, young_retired_capacity, young_retired_user - // to the Mutator partition to top it off so that it matches the running totals. - // - // Give any remnants to the Collector partition. After topping off the Collector partition, its values - // should also match running totals. + // young_retired_regions need to be added to either Mutator or Collector partitions, 100% used. + // Give enough of young_retired_regions, young_retired_capacity, young_retired_user + // to the Mutator partition to top it off so that it matches the running totals. + // + // Give any remnants to the Collector partition. After topping off the Collector partition, its values + // should also match running totals. + assert(young_retired_regions * _region_size_bytes == young_retired_capacity, "sanity"); + assert(young_retired_capacity == young_retired_used, "sanity"); - assert(young_retired_regions * _region_size_bytes == young_retired_capacity, "sanity"); - assert(young_retired_capacity == young_retired_used, "sanity"); + assert(capacities[int(ShenandoahFreeSetPartitionId::OldCollector)] + == _capacity[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old collector capacities must match (%zu != %zu)", + capacities[int(ShenandoahFreeSetPartitionId::OldCollector)], + _capacity[int(ShenandoahFreeSetPartitionId::OldCollector)]); + assert(used[int(ShenandoahFreeSetPartitionId::OldCollector)] + == _used[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old collector used must match"); + assert(regions[int(ShenandoahFreeSetPartitionId::OldCollector)] + == _capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] / _region_size_bytes, "Old collector regions must match"); + assert(_capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] + >= _used[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old Collector capacity must be >= used"); + assert(_available[int(ShenandoahFreeSetPartitionId::OldCollector)] == + (_capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] - _used[int(ShenandoahFreeSetPartitionId::OldCollector)]), + "Old Collector available must equal capacity minus used"); + assert(_humongous_waste[int(ShenandoahFreeSetPartitionId::OldCollector)] == + humongous_waste[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old Collector humongous waste must match"); + assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] >= capacities[int(ShenandoahFreeSetPartitionId::Mutator)], + "Capacity total must be >= counted tally"); + size_t mutator_capacity_shortfall = + _capacity[int(ShenandoahFreeSetPartitionId::Mutator)] - capacities[int(ShenandoahFreeSetPartitionId::Mutator)]; + assert(mutator_capacity_shortfall <= young_retired_capacity, "sanity"); + capacities[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_capacity_shortfall; + young_retired_capacity -= mutator_capacity_shortfall; + capacities[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_capacity; - assert(capacities[int(ShenandoahFreeSetPartitionId::OldCollector)] - == _capacity[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old collector capacities must match"); - assert(used[int(ShenandoahFreeSetPartitionId::OldCollector)] - == _used[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old collector used must match"); - assert(regions[int(ShenandoahFreeSetPartitionId::OldCollector)] - == _capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] / _region_size_bytes, "Old collector regions must match"); - assert(_capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] - >= _used[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old Collector capacity must be >= used"); - assert(_available[int(ShenandoahFreeSetPartitionId::OldCollector)] == - (_capacity[int(ShenandoahFreeSetPartitionId::OldCollector)] - _used[int(ShenandoahFreeSetPartitionId::OldCollector)]), - "Old Collector available must equal capacity minus used"); - assert(_humongous_waste[int(ShenandoahFreeSetPartitionId::OldCollector)] == - humongous_waste[int(ShenandoahFreeSetPartitionId::OldCollector)], "Old Collector humongous waste must match"); + assert(_used[int(ShenandoahFreeSetPartitionId::Mutator)] >= used[int(ShenandoahFreeSetPartitionId::Mutator)], + "Used total must be >= counted tally"); + size_t mutator_used_shortfall = + _used[int(ShenandoahFreeSetPartitionId::Mutator)] - used[int(ShenandoahFreeSetPartitionId::Mutator)]; + assert(mutator_used_shortfall <= young_retired_used, "sanity"); + used[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_used_shortfall; + young_retired_used -= mutator_used_shortfall; + used[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_used; - assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] >= capacities[int(ShenandoahFreeSetPartitionId::Mutator)], - "Capacity total must be >= counted tally"); - size_t mutator_capacity_shortfall = - _capacity[int(ShenandoahFreeSetPartitionId::Mutator)] - capacities[int(ShenandoahFreeSetPartitionId::Mutator)]; - assert(mutator_capacity_shortfall <= young_retired_capacity, "sanity"); - capacities[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_capacity_shortfall; - young_retired_capacity -= mutator_capacity_shortfall; - capacities[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_capacity; + assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes + >= regions[int(ShenandoahFreeSetPartitionId::Mutator)], "Region total must be >= counted tally"); + size_t mutator_regions_shortfall = (_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes + - regions[int(ShenandoahFreeSetPartitionId::Mutator)]); + assert(mutator_regions_shortfall <= young_retired_regions, "sanity"); + regions[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_regions_shortfall; + young_retired_regions -= mutator_regions_shortfall; + regions[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_regions; + assert(capacities[int(ShenandoahFreeSetPartitionId::Collector)] == _capacity[int(ShenandoahFreeSetPartitionId::Collector)], + "Collector capacities must match"); + assert(used[int(ShenandoahFreeSetPartitionId::Collector)] == _used[int(ShenandoahFreeSetPartitionId::Collector)], + "Collector used must match"); + assert(regions[int(ShenandoahFreeSetPartitionId::Collector)] + == _capacity[int(ShenandoahFreeSetPartitionId::Collector)] / _region_size_bytes, "Collector regions must match"); + assert(_capacity[int(ShenandoahFreeSetPartitionId::Collector)] >= _used[int(ShenandoahFreeSetPartitionId::Collector)], + "Collector Capacity must be >= used"); + assert(_available[int(ShenandoahFreeSetPartitionId::Collector)] == + (_capacity[int(ShenandoahFreeSetPartitionId::Collector)] - _used[int(ShenandoahFreeSetPartitionId::Collector)]), + "Collector Available must equal capacity minus used"); - assert(_used[int(ShenandoahFreeSetPartitionId::Mutator)] >= used[int(ShenandoahFreeSetPartitionId::Mutator)], - "Used total must be >= counted tally"); - size_t mutator_used_shortfall = - _used[int(ShenandoahFreeSetPartitionId::Mutator)] - used[int(ShenandoahFreeSetPartitionId::Mutator)]; - assert(mutator_used_shortfall <= young_retired_used, "sanity"); - used[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_used_shortfall; - young_retired_used -= mutator_used_shortfall; - used[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_used; - - assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes - >= regions[int(ShenandoahFreeSetPartitionId::Mutator)], "Region total must be >= counted tally"); - size_t mutator_regions_shortfall = (_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes - - regions[int(ShenandoahFreeSetPartitionId::Mutator)]); - assert(mutator_regions_shortfall <= young_retired_regions, "sanity"); - regions[int(ShenandoahFreeSetPartitionId::Mutator)] += mutator_regions_shortfall; - young_retired_regions -= mutator_regions_shortfall; - regions[int(ShenandoahFreeSetPartitionId::Collector)] += young_retired_regions; - - assert(capacities[int(ShenandoahFreeSetPartitionId::Collector)] == _capacity[int(ShenandoahFreeSetPartitionId::Collector)], - "Collector capacities must match"); - assert(used[int(ShenandoahFreeSetPartitionId::Collector)] == _used[int(ShenandoahFreeSetPartitionId::Collector)], - "Collector used must match"); - assert(regions[int(ShenandoahFreeSetPartitionId::Collector)] - == _capacity[int(ShenandoahFreeSetPartitionId::Collector)] / _region_size_bytes, "Collector regions must match"); - assert(_capacity[int(ShenandoahFreeSetPartitionId::Collector)] >= _used[int(ShenandoahFreeSetPartitionId::Collector)], - "Collector Capacity must be >= used"); - assert(_available[int(ShenandoahFreeSetPartitionId::Collector)] == - (_capacity[int(ShenandoahFreeSetPartitionId::Collector)] - _used[int(ShenandoahFreeSetPartitionId::Collector)]), - "Collector Available must equal capacity minus used"); - - assert(capacities[int(ShenandoahFreeSetPartitionId::Mutator)] == _capacity[int(ShenandoahFreeSetPartitionId::Mutator)], - "Mutator capacities must match"); - assert(used[int(ShenandoahFreeSetPartitionId::Mutator)] == _used[int(ShenandoahFreeSetPartitionId::Mutator)], - "Mutator used must match"); - assert(regions[int(ShenandoahFreeSetPartitionId::Mutator)] - == _capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes, "Mutator regions must match"); - assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] >= _used[int(ShenandoahFreeSetPartitionId::Mutator)], - "Mutator capacity must be >= used"); - assert(_available[int(ShenandoahFreeSetPartitionId::Mutator)] == - (_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] - _used[int(ShenandoahFreeSetPartitionId::Mutator)]), - "Mutator available must equal capacity minus used"); - assert(_humongous_waste[int(ShenandoahFreeSetPartitionId::Mutator)] == young_humongous_waste, - "Mutator humongous waste must match"); - } + assert(capacities[int(ShenandoahFreeSetPartitionId::Mutator)] == _capacity[int(ShenandoahFreeSetPartitionId::Mutator)], + "Mutator capacities must match"); + assert(used[int(ShenandoahFreeSetPartitionId::Mutator)] == _used[int(ShenandoahFreeSetPartitionId::Mutator)], + "Mutator used must match"); + assert(regions[int(ShenandoahFreeSetPartitionId::Mutator)] + == _capacity[int(ShenandoahFreeSetPartitionId::Mutator)] / _region_size_bytes, "Mutator regions must match"); + assert(_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] >= _used[int(ShenandoahFreeSetPartitionId::Mutator)], + "Mutator capacity must be >= used"); + assert(_available[int(ShenandoahFreeSetPartitionId::Mutator)] == + (_capacity[int(ShenandoahFreeSetPartitionId::Mutator)] - _used[int(ShenandoahFreeSetPartitionId::Mutator)]), + "Mutator available must equal capacity minus used"); + assert(_humongous_waste[int(ShenandoahFreeSetPartitionId::Mutator)] == young_humongous_waste, + "Mutator humongous waste must match"); } #endif @@ -1206,6 +1216,36 @@ ShenandoahFreeSet::ShenandoahFreeSet(ShenandoahHeap* heap, size_t max_regions) : clear_internal(); } +void ShenandoahFreeSet::move_unaffiliated_regions_from_collector_to_old_collector(ssize_t count) { + shenandoah_assert_heaplocked(); + size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes(); + + size_t old_capacity = _partitions.get_capacity(ShenandoahFreeSetPartitionId::OldCollector); + size_t collector_capacity = _partitions.get_capacity(ShenandoahFreeSetPartitionId::Collector); + if (count > 0) { + size_t ucount = count; + size_t bytes_moved = ucount * region_size_bytes; + assert(collector_capacity >= bytes_moved, "Cannot transfer"); + assert(_partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::Collector) >= ucount, + "Cannot transfer %zu of %zu", ucount, _partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::Collector)); + _partitions.decrease_empty_region_counts(ShenandoahFreeSetPartitionId::Collector, ucount); + _partitions.set_capacity_of(ShenandoahFreeSetPartitionId::Collector, collector_capacity - bytes_moved); + _partitions.set_capacity_of(ShenandoahFreeSetPartitionId::OldCollector, old_capacity + bytes_moved); + _partitions.increase_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector, ucount); + } else if (count < 0) { + size_t ucount = -count; + size_t bytes_moved = ucount * region_size_bytes; + assert(old_capacity >= bytes_moved, "Cannot transfer"); + assert(_partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector) >= ucount, + "Cannot transfer %zu of %zu", ucount, _partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector)); + _partitions.decrease_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector, ucount); + _partitions.set_capacity_of(ShenandoahFreeSetPartitionId::OldCollector, old_capacity - bytes_moved); + _partitions.set_capacity_of(ShenandoahFreeSetPartitionId::Collector, collector_capacity + bytes_moved); + _partitions.increase_empty_region_counts(ShenandoahFreeSetPartitionId::Collector, ucount); + } + // else, do nothing +} + // was pip_pad_bytes void ShenandoahFreeSet::add_promoted_in_place_region_to_old_collector(ShenandoahHeapRegion* region) { shenandoah_assert_heaplocked(); @@ -1261,7 +1301,7 @@ void ShenandoahFreeSet::add_promoted_in_place_region_to_old_collector(Shenandoah /* CollectorSizeChanged */ true, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ false, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ true>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); } template @@ -1496,9 +1536,12 @@ HeapWord* ShenandoahFreeSet::try_allocate_in(ShenandoahHeapRegion* r, Shenandoah return nullptr; } HeapWord* result = nullptr; + // We must call try_recycle_under_lock() even if !r->is_trash(). The reason is that if r is being recycled at this + // moment by a GC worker thread, it may appear to be not trash even though it has not yet been fully recycled. If + // we proceed without waiting for the worker to finish recycling the region, the worker thread may overwrite the + // region's affiliation with FREE after we set the region's affiliation to req.afiliation() below r->try_recycle_under_lock(); in_new_region = r->is_empty(); - if (in_new_region) { log_debug(gc, free)("Using new region (%zu) for %s (" PTR_FORMAT ").", r->index(), req.type_string(), p2i(&req)); @@ -1668,7 +1711,7 @@ HeapWord* ShenandoahFreeSet::try_allocate_in(ShenandoahHeapRegion* r, Shenandoah default: assert(false, "won't happen"); } - _partitions.assert_bounds(true); + _partitions.assert_bounds(); return result; } @@ -1799,6 +1842,7 @@ HeapWord* ShenandoahFreeSet::allocate_contiguous(ShenandoahAllocRequest& req, bo increase_bytes_allocated(waste_bytes); } } + _partitions.increase_used(ShenandoahFreeSetPartitionId::Mutator, total_used); increase_bytes_allocated(total_used); req.set_actual_size(words_size); @@ -1819,14 +1863,16 @@ HeapWord* ShenandoahFreeSet::allocate_contiguous(ShenandoahAllocRequest& req, bo /* CollectorSizeChanged */ false, /* OldCollectorSizeChanged */ false, /* AffiliatedChangesAreYoungNeutral */ false, /* AffiliatedChangesAreGlobalNeutral */ false, /* UnaffiliatedChangesAreYoungNeutral */ false>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); return _heap->get_region(beg)->bottom(); } class ShenandoahRecycleTrashedRegionClosure final : public ShenandoahHeapRegionClosure { public: void heap_region_do(ShenandoahHeapRegion* r) { - r->try_recycle(); + if (r->is_trash()) { + r->try_recycle(); + } } bool is_thread_safe() { @@ -1861,7 +1907,7 @@ bool ShenandoahFreeSet::transfer_one_region_from_mutator_to_old_collector(size_t /* CollectorSizeChanged */ false, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ true, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ false>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); return true; } else { return false; @@ -1914,7 +1960,7 @@ bool ShenandoahFreeSet::flip_to_old_gc(ShenandoahHeapRegion* r) { /* CollectorSizeChanged */ false, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ true, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ false>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); // 4. Do not adjust capacities for generations, we just swapped the regions that have already // been accounted for. However, we should adjust the evacuation reserves as those may have changed. shenandoah_assert_heaplocked(); @@ -1945,7 +1991,7 @@ void ShenandoahFreeSet::flip_to_gc(ShenandoahHeapRegion* r) { /* CollectorSizeChanged */ true, /* OldCollectorSizeChanged */ false, /* AffiliatedChangesAreYoungNeutral */ true, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ true>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); // We do not ensure that the region is no longer trash, relying on try_allocate_in(), which always comes next, // to recycle trash before attempting to allocate anything in the region. } @@ -2025,16 +2071,23 @@ void ShenandoahFreeSet::find_regions_with_alloc_capacity(size_t &young_trashed_r for (size_t idx = 0; idx < num_regions; idx++) { ShenandoahHeapRegion* region = _heap->get_region(idx); if (region->is_trash()) { - // Trashed regions represent immediate garbage identified by final mark and regions that had been in the collection - // partition but have not yet been "cleaned up" following update refs. + // Trashed regions represent regions that had been in the collection set (or may have been identified as immediate garbage) + // but have not yet been "cleaned up". The cset regions are not "trashed" until we have finished update refs. if (region->is_old()) { + // We're going to place this region into the Mutator set. We increment old_trashed_regions because this count represents + // regions that the old generation is entitled to without any transfer from young. We do not place this region into + // the OldCollector partition at this time. Instead, we let reserve_regions() decide whether to place this region + // into the OldCollector partition. Deferring the decision allows reserve_regions() to more effectively pack the + // OldCollector regions into high-address memory. We do not adjust capacities of old and young generations at this + // time. At the end of finish_rebuild(), the capacities are adjusted based on the results of reserve_regions(). old_trashed_regions++; } else { assert(region->is_young(), "Trashed region should be old or young"); young_trashed_regions++; } } else if (region->is_old()) { - // count both humongous and regular regions, but don't count trash (cset) regions. + // We count humongous and regular regions as "old regions". We do not count trashed regions that are old. Those + // are counted (above) as old_trashed_regions. old_region_count++; if (first_old_region > idx) { first_old_region = idx; @@ -2048,7 +2101,7 @@ void ShenandoahFreeSet::find_regions_with_alloc_capacity(size_t &young_trashed_r size_t ac = alloc_capacity(region); if (ac >= PLAB::min_size() * HeapWordSize) { if (region->is_trash() || !region->is_old()) { - // Both young and old collected regions (trashed) are placed into the Mutator set + // Both young and old (possibly immediately) collected regions (trashed) are placed into the Mutator set _partitions.raw_assign_membership(idx, ShenandoahFreeSetPartitionId::Mutator); if (idx < mutator_leftmost) { mutator_leftmost = idx; @@ -2111,10 +2164,19 @@ void ShenandoahFreeSet::find_regions_with_alloc_capacity(size_t &young_trashed_r assert(_partitions.membership(idx) == ShenandoahFreeSetPartitionId::NotFree, "Region should have been retired"); size_t humongous_waste_bytes = 0; if (region->is_humongous_start()) { - oop obj = cast_to_oop(region->bottom()); - size_t byte_size = obj->size() * HeapWordSize; - size_t region_span = ShenandoahHeapRegion::required_regions(byte_size); - humongous_waste_bytes = region_span * ShenandoahHeapRegion::region_size_bytes() - byte_size; + // Since rebuild does not necessarily happen at a safepoint, a newly allocated humongous object may not have been + // fully initialized. Therefore, we cannot safely consult its header. + ShenandoahHeapRegion* last_of_humongous_continuation = region; + size_t next_idx; + for (next_idx = idx + 1; next_idx < num_regions; next_idx++) { + ShenandoahHeapRegion* humongous_cont_candidate = _heap->get_region(next_idx); + if (!humongous_cont_candidate->is_humongous_continuation()) { + break; + } + last_of_humongous_continuation = humongous_cont_candidate; + } + // For humongous regions, used() is established while holding the global heap lock so it is reliable here + humongous_waste_bytes = ShenandoahHeapRegion::region_size_bytes() - last_of_humongous_continuation->used(); } if (region->is_old()) { old_collector_used += region_size_bytes; @@ -2183,7 +2245,7 @@ void ShenandoahFreeSet::find_regions_with_alloc_capacity(size_t &young_trashed_r /* CollectorSizeChanged */ true, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ false, /* AffiliatedChangesAreGlobalNeutral */ false, /* UnaffiliatedChangesAreYoungNeutral */ false>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); #ifdef ASSERT if (_heap->mode()->is_generational()) { assert(young_affiliated_regions() == _heap->young_generation()->get_affiliated_region_count(), "sanity"); @@ -2221,7 +2283,7 @@ void ShenandoahFreeSet::transfer_humongous_regions_from_mutator_to_old_collector /* CollectorSizeChanged */ false, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ false, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ true>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); // global_used is unaffected by this transfer // No need to adjust ranges because humongous regions are not allocatable @@ -2303,7 +2365,7 @@ void ShenandoahFreeSet::transfer_empty_regions_from_to(ShenandoahFreeSetPartitio /* UnaffiliatedChangesAreYoungNeutral */ true>(); } } - _partitions.assert_bounds(true); + _partitions.assert_bounds(); } // Returns number of regions transferred, adds transferred bytes to var argument bytes_transferred @@ -2370,7 +2432,7 @@ size_t ShenandoahFreeSet::transfer_empty_regions_from_collector_set_to_mutator_s /* AffiliatedChangesAreYoungNeutral */ true, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ true>(); } - _partitions.assert_bounds(true); + _partitions.assert_bounds(); return transferred_regions; } @@ -2445,7 +2507,7 @@ transfer_non_empty_regions_from_collector_set_to_mutator_set(ShenandoahFreeSetPa /* AffiliatedChangesAreYoungNeutral */ true, /* AffiliatedChangesAreGlobalNeutral */ true, /* UnaffiliatedChangesAreYoungNeutral */ true>(); } - _partitions.assert_bounds(true); + _partitions.assert_bounds(); return transferred_regions; } @@ -2507,14 +2569,13 @@ void ShenandoahFreeSet::prepare_to_rebuild(size_t &young_trashed_regions, size_t first_old_region, last_old_region, old_region_count); } -void ShenandoahFreeSet::finish_rebuild(size_t young_trashed_regions, size_t old_trashed_regions, size_t old_region_count, - bool have_evacuation_reserves) { + +void ShenandoahFreeSet::finish_rebuild(size_t young_cset_regions, size_t old_cset_regions, size_t old_region_count) { shenandoah_assert_heaplocked(); size_t young_reserve(0), old_reserve(0); if (_heap->mode()->is_generational()) { - compute_young_and_old_reserves(young_trashed_regions, old_trashed_regions, have_evacuation_reserves, - young_reserve, old_reserve); + compute_young_and_old_reserves(young_cset_regions, old_cset_regions, young_reserve, old_reserve); } else { young_reserve = (_heap->max_capacity() / 100) * ShenandoahEvacReserve; old_reserve = 0; @@ -2531,8 +2592,41 @@ void ShenandoahFreeSet::finish_rebuild(size_t young_trashed_regions, size_t old_ // Release the rebuild lock now. What remains in this function is read-only rebuild_lock()->unlock(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); log_status(); + if (_heap->mode()->is_generational()) { + // Clear the region balance until it is adjusted in preparation for a subsequent GC cycle. + _heap->old_generation()->set_region_balance(0); + } +} + + +// Reduce old reserve (when there are insufficient resources to satisfy the original request). +void ShenandoahFreeSet::reduce_old_reserve(size_t adjusted_old_reserve, size_t requested_old_reserve) { + ShenandoahOldGeneration* const old_generation = _heap->old_generation(); + size_t requested_promoted_reserve = old_generation->get_promoted_reserve(); + size_t requested_old_evac_reserve = old_generation->get_evacuation_reserve(); + assert(adjusted_old_reserve < requested_old_reserve, "Only allow reduction"); + assert(requested_promoted_reserve + requested_old_evac_reserve >= adjusted_old_reserve, "Sanity"); + size_t delta = requested_old_reserve - adjusted_old_reserve; + + if (requested_promoted_reserve >= delta) { + requested_promoted_reserve -= delta; + old_generation->set_promoted_reserve(requested_promoted_reserve); + } else { + delta -= requested_promoted_reserve; + requested_promoted_reserve = 0; + requested_old_evac_reserve -= delta; + old_generation->set_promoted_reserve(requested_promoted_reserve); + old_generation->set_evacuation_reserve(requested_old_evac_reserve); + } +} + +// Reduce young reserve (when there are insufficient resources to satisfy the original request). +void ShenandoahFreeSet::reduce_young_reserve(size_t adjusted_young_reserve, size_t requested_young_reserve) { + ShenandoahYoungGeneration* const young_generation = _heap->young_generation(); + assert(adjusted_young_reserve < requested_young_reserve, "Only allow reduction"); + young_generation->set_evacuation_reserve(adjusted_young_reserve); } /** @@ -2549,7 +2643,6 @@ void ShenandoahFreeSet::finish_rebuild(size_t young_trashed_regions, size_t old_ * this value should computed by ShenandoahGenerationalHeap::compute_old_generation_balance(). */ void ShenandoahFreeSet::compute_young_and_old_reserves(size_t young_trashed_regions, size_t old_trashed_regions, - bool have_evacuation_reserves, size_t& young_reserve_result, size_t& old_reserve_result) const { shenandoah_assert_generational(); shenandoah_assert_heaplocked(); @@ -2566,6 +2659,15 @@ void ShenandoahFreeSet::compute_young_and_old_reserves(size_t young_trashed_regi old_available += old_trashed_regions * region_size_bytes; young_unaffiliated_regions += young_trashed_regions; + assert(young_capacity >= young_generation->used(), + "Young capacity (%zu) must exceed used (%zu)", young_capacity, young_generation->used()); + + size_t young_available = young_capacity - young_generation->used(); + young_available += young_trashed_regions * region_size_bytes; + + assert(young_available >= young_unaffiliated_regions * region_size_bytes, "sanity"); + assert(old_available >= old_unaffiliated_regions * region_size_bytes, "sanity"); + // Consult old-region balance to make adjustments to current generation capacities and availability. // The generation region transfers take place after we rebuild. old_region_balance represents number of regions // to transfer from old to young. @@ -2585,6 +2687,7 @@ void ShenandoahFreeSet::compute_young_and_old_reserves(size_t young_trashed_regi ssize_t xfer_bytes = old_region_balance * checked_cast(region_size_bytes); old_available -= xfer_bytes; old_unaffiliated_regions -= old_region_balance; + young_available += xfer_bytes; young_capacity += xfer_bytes; young_unaffiliated_regions += old_region_balance; } @@ -2593,41 +2696,22 @@ void ShenandoahFreeSet::compute_young_and_old_reserves(size_t young_trashed_regi // promotions and evacuations. The partition between which old memory is reserved for evacuation and // which is reserved for promotion is enforced using thread-local variables that prescribe intentions for // each PLAB's available memory. - if (have_evacuation_reserves) { - // We are rebuilding at the end of final mark, having already established evacuation budgets for this GC pass. - const size_t promoted_reserve = old_generation->get_promoted_reserve(); - const size_t old_evac_reserve = old_generation->get_evacuation_reserve(); - young_reserve_result = young_generation->get_evacuation_reserve(); - old_reserve_result = promoted_reserve + old_evac_reserve; - if (old_reserve_result > old_available) { - // Try to transfer memory from young to old. - size_t old_deficit = old_reserve_result - old_available; - size_t old_region_deficit = (old_deficit + region_size_bytes - 1) / region_size_bytes; - if (young_unaffiliated_regions < old_region_deficit) { - old_region_deficit = young_unaffiliated_regions; - } - young_unaffiliated_regions -= old_region_deficit; - old_unaffiliated_regions += old_region_deficit; - old_region_balance -= old_region_deficit; - old_generation->set_region_balance(old_region_balance); - } - } else { - // We are rebuilding at end of GC, so we set aside budgets specified on command line (or defaults) - young_reserve_result = (young_capacity * ShenandoahEvacReserve) / 100; - // The auto-sizer has already made old-gen large enough to hold all anticipated evacuations and promotions. - // Affiliated old-gen regions are already in the OldCollector free set. Add in the relevant number of - // unaffiliated regions. - old_reserve_result = old_available; - } + const size_t promoted_reserve = old_generation->get_promoted_reserve(); + const size_t old_evac_reserve = old_generation->get_evacuation_reserve(); + young_reserve_result = young_generation->get_evacuation_reserve(); + old_reserve_result = promoted_reserve + old_evac_reserve; + assert(old_reserve_result + young_reserve_result <= old_available + young_available, + "Cannot reserve (%zu + %zu + %zu) more than is available: %zu + %zu", + promoted_reserve, old_evac_reserve, young_reserve_result, old_available, young_available); // Old available regions that have less than PLAB::min_size() of available memory are not placed into the OldCollector // free set. Because of this, old_available may not have enough memory to represent the intended reserve. Adjust // the reserve downward to account for this possibility. This loss is part of the reason why the original budget // was adjusted with ShenandoahOldEvacWaste and ShenandoahOldPromoWaste multipliers. if (old_reserve_result > - _partitions.capacity_of(ShenandoahFreeSetPartitionId::OldCollector) + old_unaffiliated_regions * region_size_bytes) { + _partitions.available_in(ShenandoahFreeSetPartitionId::OldCollector) + old_unaffiliated_regions * region_size_bytes) { old_reserve_result = - _partitions.capacity_of(ShenandoahFreeSetPartitionId::OldCollector) + old_unaffiliated_regions * region_size_bytes; + _partitions.available_in(ShenandoahFreeSetPartitionId::OldCollector) + old_unaffiliated_regions * region_size_bytes; } if (young_reserve_result > young_unaffiliated_regions * region_size_bytes) { @@ -2791,19 +2875,17 @@ void ShenandoahFreeSet::reserve_regions(size_t to_reserve, size_t to_reserve_old ShenandoahFreeSetPartitionId p = _partitions.membership(idx); size_t ac = alloc_capacity(r); assert(ac != region_size_bytes, "Empty regions should be in Mutator partion at entry to reserve_regions"); - if (p == ShenandoahFreeSetPartitionId::Collector) { - if (ac != region_size_bytes) { - young_used_regions++; - young_used_bytes = region_size_bytes - ac; - } - // else, unaffiliated region has no used - } else if (p == ShenandoahFreeSetPartitionId::OldCollector) { - if (ac != region_size_bytes) { - old_used_regions++; - old_used_bytes = region_size_bytes - ac; - } - // else, unaffiliated region has no used - } else if (p == ShenandoahFreeSetPartitionId::NotFree) { + assert(p != ShenandoahFreeSetPartitionId::Collector, "Collector regions must be converted from Mutator regions"); + if (p == ShenandoahFreeSetPartitionId::OldCollector) { + assert(!r->is_empty(), "Empty regions should be in Mutator partition at entry to reserve_regions"); + old_used_regions++; + old_used_bytes = region_size_bytes - ac; + // This region is within the range for OldCollector partition, as established by find_regions_with_alloc_capacity() + assert((_partitions.leftmost(ShenandoahFreeSetPartitionId::OldCollector) <= idx) && + (_partitions.rightmost(ShenandoahFreeSetPartitionId::OldCollector) >= idx), + "find_regions_with_alloc_capacity() should have established this is in range"); + } else { + assert(p == ShenandoahFreeSetPartitionId::NotFree, "sanity"); // This region has been retired if (r->is_old()) { old_used_regions++; @@ -2813,21 +2895,6 @@ void ShenandoahFreeSet::reserve_regions(size_t to_reserve, size_t to_reserve_old young_used_regions++; young_used_bytes += region_size_bytes - ac; } - } else { - assert(p == ShenandoahFreeSetPartitionId::OldCollector, "Not mutator and not NotFree, so must be OldCollector"); - assert(!r->is_empty(), "Empty regions should be in Mutator partition at entry to reserve_regions"); - if (idx < old_collector_low_idx) { - old_collector_low_idx = idx; - } - if (idx > old_collector_high_idx) { - old_collector_high_idx = idx; - } - if (idx < old_collector_empty_low_idx) { - old_collector_empty_low_idx = idx; - } - if (idx > old_collector_empty_high_idx) { - old_collector_empty_high_idx = idx; - } } } } @@ -2856,14 +2923,14 @@ void ShenandoahFreeSet::reserve_regions(size_t to_reserve, size_t to_reserve_old _partitions.increase_used(ShenandoahFreeSetPartitionId::OldCollector, used_to_old_collector); } - _partitions.expand_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::Collector, - collector_low_idx, collector_high_idx, - collector_empty_low_idx, collector_empty_high_idx); + _partitions.establish_interval(ShenandoahFreeSetPartitionId::Mutator, + mutator_low_idx, mutator_high_idx, mutator_empty_low_idx, mutator_empty_high_idx); + _partitions.establish_interval(ShenandoahFreeSetPartitionId::Collector, + collector_low_idx, collector_high_idx, collector_empty_low_idx, collector_empty_high_idx); + _partitions.expand_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::OldCollector, old_collector_low_idx, old_collector_high_idx, old_collector_empty_low_idx, old_collector_empty_high_idx); - _partitions.establish_interval(ShenandoahFreeSetPartitionId::Mutator, - mutator_low_idx, mutator_high_idx, mutator_empty_low_idx, mutator_empty_high_idx); recompute_total_used(); @@ -2872,17 +2939,22 @@ void ShenandoahFreeSet::reserve_regions(size_t to_reserve, size_t to_reserve_old /* CollectorSizeChanged */ true, /* OldCollectorSizeChanged */ true, /* AffiliatedChangesAreYoungNeutral */ false, /* AffiliatedChangesAreGlobalNeutral */ false, /* UnaffiliatedChangesAreYoungNeutral */ false>(); - _partitions.assert_bounds(true); + _partitions.assert_bounds(); if (LogTarget(Info, gc, free)::is_enabled()) { size_t old_reserve = _partitions.available_in(ShenandoahFreeSetPartitionId::OldCollector); if (old_reserve < to_reserve_old) { log_info(gc, free)("Wanted " PROPERFMT " for old reserve, but only reserved: " PROPERFMT, PROPERFMTARGS(to_reserve_old), PROPERFMTARGS(old_reserve)); + assert(_heap->mode()->is_generational(), "to_old_reserve > 0 implies generational mode"); + reduce_old_reserve(old_reserve, to_reserve_old); } size_t reserve = _partitions.available_in(ShenandoahFreeSetPartitionId::Collector); if (reserve < to_reserve) { + if (_heap->mode()->is_generational()) { + reduce_young_reserve(reserve, to_reserve); + } log_info(gc, free)("Wanted " PROPERFMT " for young reserve, but only reserved: " PROPERFMT, - PROPERFMTARGS(to_reserve), PROPERFMTARGS(reserve)); + PROPERFMTARGS(to_reserve), PROPERFMTARGS(reserve)); } } } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.hpp index 364637740f2..4e0aea80a9b 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahFreeSet.hpp @@ -224,6 +224,10 @@ public: void transfer_used_capacity_from_to(ShenandoahFreeSetPartitionId from_partition, ShenandoahFreeSetPartitionId to_partition, size_t regions); + // For recycled region r in the OldCollector partition but possibly not within the interval for empty OldCollector regions, + // expand the empty interval to include this region. + inline void adjust_interval_for_recycled_old_region_under_lock(ShenandoahHeapRegion* r); + const char* partition_membership_name(idx_t idx) const; // Return the index of the next available region >= start_index, or maximum_regions if not found. @@ -373,12 +377,7 @@ public: inline void set_capacity_of(ShenandoahFreeSetPartitionId which_partition, size_t value); - inline void set_used_by(ShenandoahFreeSetPartitionId which_partition, size_t value) { - shenandoah_assert_heaplocked(); - assert (which_partition < NumPartitions, "selected free set must be valid"); - _used[int(which_partition)] = value; - _available[int(which_partition)] = _capacity[int(which_partition)] - value; - } + inline void set_used_by(ShenandoahFreeSetPartitionId which_partition, size_t value); inline size_t count(ShenandoahFreeSetPartitionId which_partition) const { return _region_counts[int(which_partition)]; } @@ -402,7 +401,7 @@ public: // idx >= leftmost && // idx <= rightmost // } - void assert_bounds(bool validate_totals) NOT_DEBUG_RETURN; + void assert_bounds() NOT_DEBUG_RETURN; }; // Publicly, ShenandoahFreeSet represents memory that is available to mutator threads. The public capacity(), used(), @@ -634,7 +633,11 @@ private: void establish_old_collector_alloc_bias(); size_t get_usable_free_words(size_t free_bytes) const; + void reduce_young_reserve(size_t adjusted_young_reserve, size_t requested_young_reserve); + void reduce_old_reserve(size_t adjusted_old_reserve, size_t requested_old_reserve); + void log_freeset_stats(ShenandoahFreeSetPartitionId partition_id, LogStream& ls); + // log status, assuming lock has already been acquired by the caller. void log_status(); @@ -685,35 +688,46 @@ public: return _total_global_used; } - size_t global_unaffiliated_regions() { + // A negative argument results in moving from old_collector to collector + void move_unaffiliated_regions_from_collector_to_old_collector(ssize_t regions); + + inline size_t global_unaffiliated_regions() { return _global_unaffiliated_regions; } - size_t young_unaffiliated_regions() { + inline size_t young_unaffiliated_regions() { return _young_unaffiliated_regions; } - size_t old_unaffiliated_regions() { + inline size_t collector_unaffiliated_regions() { + return _partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::Collector); + } + + inline size_t old_collector_unaffiliated_regions() { return _partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector); } - size_t young_affiliated_regions() { + inline size_t old_unaffiliated_regions() { + return _partitions.get_empty_region_counts(ShenandoahFreeSetPartitionId::OldCollector); + } + + inline size_t young_affiliated_regions() { return _young_affiliated_regions; } - size_t old_affiliated_regions() { + inline size_t old_affiliated_regions() { return _old_affiliated_regions; } - size_t global_affiliated_regions() { + inline size_t global_affiliated_regions() { return _global_affiliated_regions; } - size_t total_young_regions() { + inline size_t total_young_regions() { return _total_young_regions; } - size_t total_old_regions() { + inline size_t total_old_regions() { return _partitions.get_capacity(ShenandoahFreeSetPartitionId::OldCollector) / ShenandoahHeapRegion::region_size_bytes(); } @@ -725,36 +739,27 @@ public: // Examine the existing free set representation, capturing the current state into var arguments: // - // young_cset_regions is the number of regions currently in the young cset if we are starting to evacuate, or zero - // old_cset_regions is the number of regions currently in the old cset if we are starting a mixed evacuation, or zero + // young_trashed_regions is the number of trashed regions (immediate garbage at final mark, cset regions after update refs) + // old_trashed_regions is the number of trashed regions + // (immediate garbage at final old mark, cset regions after update refs for mixed evac) // first_old_region is the index of the first region that is part of the OldCollector set // last_old_region is the index of the last region that is part of the OldCollector set // old_region_count is the number of regions in the OldCollector set that have memory available to be allocated - void prepare_to_rebuild(size_t &young_cset_regions, size_t &old_cset_regions, + void prepare_to_rebuild(size_t &young_trashed_regions, size_t &old_trashed_regions, size_t &first_old_region, size_t &last_old_region, size_t &old_region_count); // At the end of final mark, but before we begin evacuating, heuristics calculate how much memory is required to - // hold the results of evacuating to young-gen and to old-gen, and have_evacuation_reserves should be true. - // These quantities, stored as reserves for their respective generations, are consulted prior to rebuilding - // the free set (ShenandoahFreeSet) in preparation for evacuation. When the free set is rebuilt, we make sure - // to reserve sufficient memory in the collector and old_collector sets to hold evacuations. + // hold the results of evacuating to young-gen and to old-gen. These quantities, stored in reserves for their + // respective generations, are consulted prior to rebuilding the free set (ShenandoahFreeSet) in preparation for + // evacuation. When the free set is rebuilt, we make sure to reserve sufficient memory in the collector and + // old_collector sets to hold evacuations. Likewise, at the end of update refs, we rebuild the free set in order + // to set aside reserves to be consumed during the next GC cycle. // - // We also rebuild the free set at the end of GC, as we prepare to idle GC until the next trigger. In this case, - // have_evacuation_reserves is false because we don't yet know how much memory will need to be evacuated in the - // next GC cycle. When have_evacuation_reserves is false, the free set rebuild operation reserves for the collector - // and old_collector sets based on alternative mechanisms, such as ShenandoahEvacReserve, ShenandoahOldEvacReserve, and - // ShenandoahOldCompactionReserve. In a future planned enhancement, the reserve for old_collector set when the - // evacuation reserves are unknown, is based in part on anticipated promotion as determined by analysis of live data - // found during the previous GC pass which is one less than the current tenure age. - // - // young_cset_regions is the number of regions currently in the young cset if we are starting to evacuate, or zero - // old_cset_regions is the number of regions currently in the old cset if we are starting a mixed evacuation, or zero + // young_trashed_regions is the number of trashed regions (immediate garbage at final mark, cset regions after update refs) + // old_trashed_regions is the number of trashed regions + // (immediate garbage at final old mark, cset regions after update refs for mixed evac) // num_old_regions is the number of old-gen regions that have available memory for further allocations (excluding old cset) - // have_evacuation_reserves is true iff the desired values of young-gen and old-gen evacuation reserves and old-gen - // promotion reserve have been precomputed (and can be obtained by invoking - // ->get_evacuation_reserve() or old_gen->get_promoted_reserve() - void finish_rebuild(size_t young_cset_regions, size_t old_cset_regions, size_t num_old_regions, - bool have_evacuation_reserves = false); + void finish_rebuild(size_t young_trashed_regions, size_t old_trashed_regions, size_t num_old_regions); // When a region is promoted in place, we add the region's available memory if it is greater than plab_min_size() // into the old collector partition by invoking this method. @@ -806,9 +811,18 @@ public: return _partitions.available_in_locked_for_rebuild(ShenandoahFreeSetPartitionId::Mutator); } + // Use this version of available() if the heap lock is held. + inline size_t available_locked() const { + return _partitions.available_in(ShenandoahFreeSetPartitionId::Mutator); + } + inline size_t total_humongous_waste() const { return _total_humongous_waste; } - inline size_t humongous_waste_in_mutator() const { return _partitions.humongous_waste(ShenandoahFreeSetPartitionId::Mutator); } - inline size_t humongous_waste_in_old() const { return _partitions.humongous_waste(ShenandoahFreeSetPartitionId::OldCollector); } + inline size_t humongous_waste_in_mutator() const { + return _partitions.humongous_waste(ShenandoahFreeSetPartitionId::Mutator); + } + inline size_t humongous_waste_in_old() const { + return _partitions.humongous_waste(ShenandoahFreeSetPartitionId::OldCollector); + } void decrease_humongous_waste_for_regular_bypass(ShenandoahHeapRegion* r, size_t waste); @@ -874,7 +888,7 @@ public: // Reserve space for evacuations, with regions reserved for old evacuations placed to the right // of regions reserved of young evacuations. - void compute_young_and_old_reserves(size_t young_cset_regions, size_t old_cset_regions, bool have_evacuation_reserves, + void compute_young_and_old_reserves(size_t young_cset_regions, size_t old_cset_regions, size_t &young_reserve_result, size_t &old_reserve_result) const; }; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp index fa3a7a42209..3c92750cc0c 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp @@ -522,6 +522,7 @@ public: void heap_region_do(ShenandoahHeapRegion* r) override { if (r->is_trash()) { r->try_recycle_under_lock(); + // No need to adjust_interval_for_recycled_old_region. That will be taken care of during freeset rebuild. } if (r->is_cset()) { // Leave affiliation unchanged @@ -966,6 +967,7 @@ public: if (r->is_trash()) { live = 0; r->try_recycle_under_lock(); + // No need to adjust_interval_for_recycled_old_region. That will be taken care of during freeset rebuild. } else { if (r->is_old()) { ShenandoahGenerationalFullGC::account_for_region(r, _old_regions, _old_usage, _old_humongous_waste); @@ -1113,16 +1115,16 @@ void ShenandoahFullGC::phase5_epilog() { ShenandoahPostCompactClosure post_compact; heap->heap_region_iterate(&post_compact); heap->collection_set()->clear(); - size_t young_cset_regions, old_cset_regions, first_old, last_old, num_old; - ShenandoahFreeSet* free_set = heap->free_set(); { - free_set->prepare_to_rebuild(young_cset_regions, old_cset_regions, first_old, last_old, num_old); + ShenandoahFreeSet* free_set = heap->free_set(); + size_t young_trashed_regions, old_trashed_regions, first_old, last_old, num_old; + free_set->prepare_to_rebuild(young_trashed_regions, old_trashed_regions, first_old, last_old, num_old); // We also do not expand old generation size following Full GC because we have scrambled age populations and // no longer have objects separated by age into distinct regions. if (heap->mode()->is_generational()) { ShenandoahGenerationalFullGC::compute_balances(); } - free_set->finish_rebuild(young_cset_regions, old_cset_regions, num_old); + free_set->finish_rebuild(young_trashed_regions, old_trashed_regions, num_old); } // Set mark incomplete because the marking bitmaps have been reset except pinned regions. _generation->set_mark_incomplete(); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp index a5d8cca458d..cdc7e1a328a 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp @@ -250,6 +250,7 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap ShenandoahOldGeneration* const old_generation = heap->old_generation(); ShenandoahYoungGeneration* const young_generation = heap->young_generation(); + const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes(); // During initialization and phase changes, it is more likely that fewer objects die young and old-gen // memory is not yet full (or is in the process of being replaced). During these times especially, it @@ -263,15 +264,15 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap // First priority is to reclaim the easy garbage out of young-gen. - // maximum_young_evacuation_reserve is upper bound on memory to be evacuated out of young - const size_t maximum_young_evacuation_reserve = (young_generation->max_capacity() * ShenandoahEvacReserve) / 100; - size_t young_evacuation_reserve = MIN2(maximum_young_evacuation_reserve, young_generation->available_with_reserve()); + // maximum_young_evacuation_reserve is upper bound on memory to be evacuated into young Collector Reserve. This is + // bounded at the end of previous GC cycle, based on available memory and balancing of evacuation to old and young. + size_t maximum_young_evacuation_reserve = young_generation->get_evacuation_reserve(); // maximum_old_evacuation_reserve is an upper bound on memory evacuated from old and evacuated to old (promoted), // clamped by the old generation space available. // // Here's the algebra. - // Let SOEP = ShenandoahOldEvacRatioPercent, + // Let SOEP = ShenandoahOldEvacPercent, // OE = old evac, // YE = young evac, and // TE = total evac = OE + YE @@ -283,12 +284,14 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap // => OE = YE*SOEP/(100-SOEP) // We have to be careful in the event that SOEP is set to 100 by the user. - assert(ShenandoahOldEvacRatioPercent <= 100, "Error"); + assert(ShenandoahOldEvacPercent <= 100, "Error"); const size_t old_available = old_generation->available(); - const size_t maximum_old_evacuation_reserve = (ShenandoahOldEvacRatioPercent == 100) ? - old_available : MIN2((maximum_young_evacuation_reserve * ShenandoahOldEvacRatioPercent) / (100 - ShenandoahOldEvacRatioPercent), + const size_t maximum_old_evacuation_reserve = (ShenandoahOldEvacPercent == 100) ? + old_available : MIN2((maximum_young_evacuation_reserve * ShenandoahOldEvacPercent) / (100 - ShenandoahOldEvacPercent), old_available); + // In some cases, maximum_old_reserve < old_available (when limited by ShenandoahOldEvacPercent) + // This limit affects mixed evacuations, but does not affect promotions. // Second priority is to reclaim garbage out of old-gen if there are old-gen collection candidates. Third priority // is to promote as much as we have room to promote. However, if old-gen memory is in short supply, this means young @@ -305,10 +308,8 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap // evacuation and update-refs, we give emphasis to reclaiming garbage first, wherever that garbage is found. // Global GC will adjust generation sizes to accommodate the collection set it chooses. - // Set old_promo_reserve to enforce that no regions are preselected for promotion. Such regions typically - // have relatively high memory utilization. We still call select_aged_regions() because this will prepare for - // promotions in place, if relevant. - old_promo_reserve = 0; + // Use remnant of old_available to hold promotions. + old_promo_reserve = old_available - maximum_old_evacuation_reserve; // Dedicate all available old memory to old_evacuation reserve. This may be small, because old-gen is only // expanded based on an existing mixed evacuation workload at the end of the previous GC cycle. We'll expand @@ -319,43 +320,48 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap // mixed evacuation, reserve all of this memory for compaction of old-gen and do not promote. Prioritize compaction // over promotion in order to defragment OLD so that it will be better prepared to efficiently receive promoted memory. old_evacuation_reserve = maximum_old_evacuation_reserve; - old_promo_reserve = 0; + old_promo_reserve = old_available - maximum_old_evacuation_reserve; } else { // Make all old-evacuation memory for promotion, but if we can't use it all for promotion, we'll allow some evacuation. - old_evacuation_reserve = 0; + old_evacuation_reserve = old_available - maximum_old_evacuation_reserve; old_promo_reserve = maximum_old_evacuation_reserve; } assert(old_evacuation_reserve <= old_available, "Error"); + // We see too many old-evacuation failures if we force ourselves to evacuate into regions that are not initially empty. // So we limit the old-evacuation reserve to unfragmented memory. Even so, old-evacuation is free to fill in nooks and // crannies within existing partially used regions and it generally tries to do so. - const size_t old_free_unfragmented = old_generation->free_unaffiliated_regions() * ShenandoahHeapRegion::region_size_bytes(); + const size_t old_free_unfragmented = old_generation->free_unaffiliated_regions() * region_size_bytes; if (old_evacuation_reserve > old_free_unfragmented) { const size_t delta = old_evacuation_reserve - old_free_unfragmented; old_evacuation_reserve -= delta; - // Let promo consume fragments of old-gen memory if not global - if (!is_global()) { - old_promo_reserve += delta; - } + // Let promo consume fragments of old-gen memory + old_promo_reserve += delta; } - // Preselect regions for promotion by evacuation (obtaining the live data to seed promoted_reserve), - // and identify regions that will promote in place. These use the tenuring threshold. - const size_t consumed_by_advance_promotion = select_aged_regions(old_promo_reserve); - assert(consumed_by_advance_promotion <= maximum_old_evacuation_reserve, "Cannot promote more than available old-gen memory"); + // If is_global(), we let garbage-first heuristic determine cset membership. Otherwise, we give priority + // to tenurable regions by preselecting regions for promotion by evacuation (obtaining the live data to seed promoted_reserve). + // This also identifies regions that will be promoted in place. These use the tenuring threshold. + const size_t consumed_by_advance_promotion = select_aged_regions(is_global()? 0: old_promo_reserve); + assert(consumed_by_advance_promotion <= old_promo_reserve, "Do not promote more than budgeted"); + + // The young evacuation reserve can be no larger than young_unaffiliated. Planning to evacuate into partially consumed + // young regions is doomed to failure if any of those partially consumed regions is selected for the collection set. + size_t young_unaffiliated = young_generation->free_unaffiliated_regions() * region_size_bytes; // If any regions have been selected for promotion in place, this has the effect of decreasing available within mutator // and collector partitions, due to padding of remnant memory within each promoted in place region. This will affect // young_evacuation_reserve but not old_evacuation_reserve or consumed_by_advance_promotion. So recompute. - young_evacuation_reserve = MIN2(young_evacuation_reserve, young_generation->available_with_reserve()); + size_t young_evacuation_reserve = MIN2(maximum_young_evacuation_reserve, young_unaffiliated); // Note that unused old_promo_reserve might not be entirely consumed_by_advance_promotion. Do not transfer this // to old_evacuation_reserve because this memory is likely very fragmented, and we do not want to increase the likelihood - // of old evacuation failure. + // of old evacuation failure. Leave this memory in the promoted reserve as it may be targeted by opportunistic + // promotions (found during evacuation of young regions). young_generation->set_evacuation_reserve(young_evacuation_reserve); old_generation->set_evacuation_reserve(old_evacuation_reserve); - old_generation->set_promoted_reserve(consumed_by_advance_promotion); + old_generation->set_promoted_reserve(old_promo_reserve); // There is no need to expand OLD because all memory used here was set aside at end of previous GC, except in the // case of a GLOBAL gc. During choose_collection_set() of GLOBAL, old will be expanded on demand. @@ -363,8 +369,8 @@ void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap // Having chosen the collection set, adjust the budgets for generational mode based on its composition. Note // that young_generation->available() now knows about recently discovered immediate garbage. -// -void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, ShenandoahCollectionSet* const collection_set) { +void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, + ShenandoahCollectionSet* const collection_set, size_t add_regions_to_old) { shenandoah_assert_generational(); // We may find that old_evacuation_reserve and/or loaned_for_young_evacuation are not fully consumed, in which case we may // be able to increase regions_available_to_loan @@ -398,7 +404,8 @@ void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, // Leave old_evac_reserve as previously configured } else if (old_evacuated_committed < old_evacuation_reserve) { // This happens if the old-gen collection consumes less than full budget. - log_debug(gc, cset)("Shrinking old evac reserve to match old_evac_commited: " PROPERFMT, PROPERFMTARGS(old_evacuated_committed)); + log_debug(gc, cset)("Shrinking old evac reserve to match old_evac_commited: " PROPERFMT, + PROPERFMTARGS(old_evacuated_committed)); old_evacuation_reserve = old_evacuated_committed; old_generation->set_evacuation_reserve(old_evacuation_reserve); } @@ -409,11 +416,17 @@ void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, size_t young_evacuated = collection_set->get_live_bytes_in_untenurable_regions(); size_t young_evacuated_reserve_used = (size_t) (ShenandoahEvacWaste * double(young_evacuated)); - size_t total_young_available = young_generation->available_with_reserve(); - assert(young_evacuated_reserve_used <= total_young_available, "Cannot evacuate more than is available in young"); + size_t total_young_available = young_generation->available_with_reserve() - add_regions_to_old * region_size_bytes;; + assert(young_evacuated_reserve_used <= total_young_available, "Cannot evacuate (%zu) more than is available in young (%zu)", + young_evacuated_reserve_used, total_young_available); young_generation->set_evacuation_reserve(young_evacuated_reserve_used); - size_t old_available = old_generation->available(); + // We have not yet rebuilt the free set. Some of the memory that is thought to be avaiable within old may no + // longer be available if that memory had been free within regions that were selected for the collection set. + // Make the necessary adjustments to old_available. + size_t old_available = + old_generation->available() + add_regions_to_old * region_size_bytes - collection_set->get_old_available_bytes_collected(); + // Now that we've established the collection set, we know how much memory is really required by old-gen for evacuation // and promotion reserves. Try shrinking OLD now in case that gives us a bit more runway for mutator allocations during // evac and update phases. @@ -422,21 +435,27 @@ void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, if (old_available < old_consumed) { // This can happen due to round-off errors when adding the results of truncated integer arithmetic. // We've already truncated old_evacuated_committed. Truncate young_advance_promoted_reserve_used here. + assert(young_advance_promoted_reserve_used <= (33 * (old_available - old_evacuated_committed)) / 32, "Round-off errors should be less than 3.125%%, committed: %zu, reserved: %zu", young_advance_promoted_reserve_used, old_available - old_evacuated_committed); - young_advance_promoted_reserve_used = old_available - old_evacuated_committed; + if (old_available > old_evacuated_committed) { + young_advance_promoted_reserve_used = old_available - old_evacuated_committed; + } else { + young_advance_promoted_reserve_used = 0; + old_evacuated_committed = old_available; + } + // TODO: reserve for full promotion reserve, not just for advance (preselected) promotion old_consumed = old_evacuated_committed + young_advance_promoted_reserve_used; } assert(old_available >= old_consumed, "Cannot consume (%zu) more than is available (%zu)", old_consumed, old_available); size_t excess_old = old_available - old_consumed; - size_t unaffiliated_old_regions = old_generation->free_unaffiliated_regions(); + size_t unaffiliated_old_regions = old_generation->free_unaffiliated_regions() + add_regions_to_old; size_t unaffiliated_old = unaffiliated_old_regions * region_size_bytes; - assert(old_available >= unaffiliated_old, - "Unaffiliated old (%zu is %zu * %zu) is a subset of old available (%zu)", - unaffiliated_old, unaffiliated_old_regions, region_size_bytes, old_available); + assert(unaffiliated_old >= old_evacuated_committed, "Do not evacuate (%zu) more than unaffiliated old (%zu)", + old_evacuated_committed, unaffiliated_old); // Make sure old_evac_committed is unaffiliated if (old_evacuated_committed > 0) { @@ -454,20 +473,22 @@ void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, } // If we find that OLD has excess regions, give them back to YOUNG now to reduce likelihood we run out of allocation - // runway during evacuation and update-refs. - size_t regions_to_xfer = 0; + // runway during evacuation and update-refs. We may make further adjustments to balance. + ssize_t add_regions_to_young = 0; if (excess_old > unaffiliated_old) { // we can give back unaffiliated_old (all of unaffiliated is excess) if (unaffiliated_old_regions > 0) { - regions_to_xfer = unaffiliated_old_regions; + add_regions_to_young = unaffiliated_old_regions; } } else if (unaffiliated_old_regions > 0) { // excess_old < unaffiliated old: we can give back MIN(excess_old/region_size_bytes, unaffiliated_old_regions) size_t excess_regions = excess_old / region_size_bytes; - regions_to_xfer = MIN2(excess_regions, unaffiliated_old_regions); + add_regions_to_young = MIN2(excess_regions, unaffiliated_old_regions); } - if (regions_to_xfer > 0) { - excess_old -= regions_to_xfer * region_size_bytes; + + if (add_regions_to_young > 0) { + assert(excess_old >= add_regions_to_young * region_size_bytes, "Cannot xfer more than excess old"); + excess_old -= add_regions_to_young * region_size_bytes; log_debug(gc, ergo)("Before start of evacuation, total_promotion reserve is young_advance_promoted_reserve: %zu " "plus excess: old: %zu", young_advance_promoted_reserve_used, excess_old); } @@ -475,6 +496,7 @@ void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap, // Add in the excess_old memory to hold unanticipated promotions, if any. If there are more unanticipated // promotions than fit in reserved memory, they will be deferred until a future GC pass. size_t total_promotion_reserve = young_advance_promoted_reserve_used + excess_old; + old_generation->set_promoted_reserve(total_promotion_reserve); old_generation->reset_promoted_expended(); } @@ -782,17 +804,13 @@ void ShenandoahGeneration::prepare_regions_and_collection_set(bool concurrent) { ShenandoahCollectionSetPreselector preselector(collection_set, heap->num_regions()); // Find the amount that will be promoted, regions that will be promoted in - // place, and preselect older regions that will be promoted by evacuation. + // place, and preselected older regions that will be promoted by evacuation. compute_evacuation_budgets(heap); - // Choose the collection set, including the regions preselected above for - // promotion into the old generation. - _heuristics->choose_collection_set(collection_set); - if (!collection_set->is_empty()) { - // only make use of evacuation budgets when we are evacuating - adjust_evacuation_budgets(heap, collection_set); - } - + // Choose the collection set, including the regions preselected above for promotion into the old generation. + size_t add_regions_to_old = _heuristics->choose_collection_set(collection_set); + // Even if collection_set->is_empty(), we want to adjust budgets, making reserves available to mutator. + adjust_evacuation_budgets(heap, collection_set, add_regions_to_old); if (is_global()) { // We have just chosen a collection set for a global cycle. The mark bitmap covering old regions is complete, so // the remembered set scan can use that to avoid walking into garbage. When the next old mark begins, we will @@ -816,17 +834,16 @@ void ShenandoahGeneration::prepare_regions_and_collection_set(bool concurrent) { ShenandoahPhaseTimings::degen_gc_final_rebuild_freeset); ShenandoahHeapLocker locker(heap->lock()); - // We are preparing for evacuation. At this time, we ignore cset region tallies. - size_t young_cset_regions, old_cset_regions, first_old, last_old, num_old; - _free_set->prepare_to_rebuild(young_cset_regions, old_cset_regions, first_old, last_old, num_old); - + // We are preparing for evacuation. + size_t young_trashed_regions, old_trashed_regions, first_old, last_old, num_old; + _free_set->prepare_to_rebuild(young_trashed_regions, old_trashed_regions, first_old, last_old, num_old); if (heap->mode()->is_generational()) { ShenandoahGenerationalHeap* gen_heap = ShenandoahGenerationalHeap::heap(); - gen_heap->compute_old_generation_balance(young_cset_regions, old_cset_regions); + size_t allocation_runway = + gen_heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(young_trashed_regions); + gen_heap->compute_old_generation_balance(allocation_runway, old_trashed_regions, young_trashed_regions); } - - // Free set construction uses reserve quantities, because they are known to be valid here - _free_set->finish_rebuild(young_cset_regions, old_cset_regions, num_old, true); + _free_set->finish_rebuild(young_trashed_regions, old_trashed_regions, num_old); } } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp index 06cf132f946..d49e3bed5f8 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp @@ -63,9 +63,10 @@ private: // Compute evacuation budgets prior to choosing collection set. void compute_evacuation_budgets(ShenandoahHeap* heap); - // Adjust evacuation budgets after choosing collection set. + // Adjust evacuation budgets after choosing collection set. The argument regions_to_xfer represents regions to be + // transfered to old based on decisions made in top_off_collection_set() void adjust_evacuation_budgets(ShenandoahHeap* heap, - ShenandoahCollectionSet* collection_set); + ShenandoahCollectionSet* collection_set, size_t regions_to_xfer); // Preselect for possible inclusion into the collection set exactly the most // garbage-dense regions, including those that satisfy criteria 1 & 2 below, @@ -144,6 +145,22 @@ private: virtual void prepare_gc(); // Called during final mark, chooses collection set, rebuilds free set. + // Upon return from prepare_regions_and_collection_set(), certain parameters have been established to govern the + // evacuation efforts that are about to begin. In particular: + // + // old_generation->get_promoted_reserve() represents the amount of memory within old-gen's available memory that has + // been set aside to hold objects promoted from young-gen memory. This represents an estimated percentage + // of the live young-gen memory within the collection set. If there is more data ready to be promoted than + // can fit within this reserve, the promotion of some objects will be deferred until a subsequent evacuation + // pass. + // + // old_generation->get_evacuation_reserve() represents the amount of memory within old-gen's available memory that has been + // set aside to hold objects evacuated from the old-gen collection set. + // + // young_generation->get_evacuation_reserve() represents the amount of memory within young-gen's available memory that has + // been set aside to hold objects evacuated from the young-gen collection set. Conservatively, this value + // equals the entire amount of live young-gen memory within the collection set, even though some of this memory + // will likely be promoted. virtual void prepare_regions_and_collection_set(bool concurrent); // Cancel marking (used by Full collect and when cancelling cycle). diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.cpp index 78672ee10a5..1b11c696d18 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.cpp @@ -55,9 +55,6 @@ void ShenandoahGenerationalFullGC::prepare() { // Since we may arrive here from degenerated GC failure of either young or old, establish generation as GLOBAL. heap->set_active_generation(heap->global_generation()); - // No need for old_gen->increase_used() as this was done when plabs were allocated. - heap->reset_generation_reserves(); - // Full GC supersedes any marking or coalescing in old generation. heap->old_generation()->cancel_gc(); } @@ -156,8 +153,11 @@ void ShenandoahGenerationalFullGC::compute_balances() { // In case this Full GC resulted from degeneration, clear the tally on anticipated promotion. heap->old_generation()->set_promotion_potential(0); - // Invoke this in case we are able to transfer memory from OLD to YOUNG. - heap->compute_old_generation_balance(0, 0); + + // Invoke this in case we are able to transfer memory from OLD to YOUNG + size_t allocation_runway = + heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(0L); + heap->compute_old_generation_balance(allocation_runway, 0, 0); } ShenandoahPrepareForGenerationalCompactionObjectClosure::ShenandoahPrepareForGenerationalCompactionObjectClosure(PreservedMarks* preserved_marks, diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.cpp index fa78e02e6af..36ea0b9e497 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.cpp @@ -299,9 +299,9 @@ oop ShenandoahGenerationalHeap::try_evacuate_object(oop p, Thread* thread, uint alloc_from_lab = false; } // else, we leave copy equal to nullptr, signaling a promotion failure below if appropriate. - // We choose not to promote objects smaller than PLAB::min_size() by way of shared allocations, as this is too + // We choose not to promote objects smaller than size_threshold by way of shared allocations as this is too // costly. Instead, we'll simply "evacuate" to young-gen memory (using a GCLAB) and will promote in a future - // evacuation pass. This condition is denoted by: is_promotion && has_plab && (size <= PLAB::min_size()) + // evacuation pass. This condition is denoted by: is_promotion && has_plab && (size <= size_threshhold). } #ifdef ASSERT } @@ -576,19 +576,18 @@ void ShenandoahGenerationalHeap::retire_plab(PLAB* plab) { // Make sure old-generation is large enough, but no larger than is necessary, to hold mixed evacuations // and promotions, if we anticipate either. Any deficit is provided by the young generation, subject to -// xfer_limit, and any surplus is transferred to the young generation. -// -// xfer_limit is the maximum we're able to transfer from young to old based on either: -// 1. an assumption that we will be able to replenish memory "borrowed" from young at the end of collection, or -// 2. there is sufficient excess in the allocation runway during GC idle cycles -void ShenandoahGenerationalHeap::compute_old_generation_balance(size_t old_xfer_limit, size_t old_cset_regions) { - +// mutator_xfer_limit, and any surplus is transferred to the young generation. mutator_xfer_limit is +// the maximum we're able to transfer from young to old. This is called at the end of GC, as we prepare +// for the idle span that precedes the next GC. +void ShenandoahGenerationalHeap::compute_old_generation_balance(size_t mutator_xfer_limit, + size_t old_trashed_regions, size_t young_trashed_regions) { + shenandoah_assert_heaplocked(); // We can limit the old reserve to the size of anticipated promotions: // max_old_reserve is an upper bound on memory evacuated from old and promoted to old, // clamped by the old generation space available. // // Here's the algebra. - // Let SOEP = ShenandoahOldEvacRatioPercent, + // Let SOEP = ShenandoahOldEvacPercent, // OE = old evac, // YE = young evac, and // TE = total evac = OE + YE @@ -600,81 +599,171 @@ void ShenandoahGenerationalHeap::compute_old_generation_balance(size_t old_xfer_ // => OE = YE*SOEP/(100-SOEP) // We have to be careful in the event that SOEP is set to 100 by the user. - assert(ShenandoahOldEvacRatioPercent <= 100, "Error"); - const size_t old_available = old_generation()->available(); - // The free set will reserve this amount of memory to hold young evacuations - const size_t young_reserve = (young_generation()->max_capacity() * ShenandoahEvacReserve) / 100; - - // In the case that ShenandoahOldEvacRatioPercent equals 100, max_old_reserve is limited only by xfer_limit. - - const double bound_on_old_reserve = old_available + old_xfer_limit + young_reserve; - const double max_old_reserve = ((ShenandoahOldEvacRatioPercent == 100)? bound_on_old_reserve: - MIN2(double(young_reserve * ShenandoahOldEvacRatioPercent) - / double(100 - ShenandoahOldEvacRatioPercent), bound_on_old_reserve)); - + assert(ShenandoahOldEvacPercent <= 100, "Error"); const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes(); + ShenandoahOldGeneration* old_gen = old_generation(); + size_t old_capacity = old_gen->max_capacity(); + size_t old_usage = old_gen->used(); // includes humongous waste + size_t old_available = ((old_capacity >= old_usage)? old_capacity - old_usage: 0) + old_trashed_regions * region_size_bytes; + + ShenandoahYoungGeneration* young_gen = young_generation(); + size_t young_capacity = young_gen->max_capacity(); + size_t young_usage = young_gen->used(); // includes humongous waste + size_t young_available = ((young_capacity >= young_usage)? young_capacity - young_usage: 0); + size_t freeset_available = free_set()->available_locked(); + if (young_available > freeset_available) { + young_available = freeset_available; + } + young_available += young_trashed_regions * region_size_bytes; + + // The free set will reserve this amount of memory to hold young evacuations (initialized to the ideal reserve) + size_t young_reserve = (young_generation()->max_capacity() * ShenandoahEvacReserve) / 100; + + // If ShenandoahOldEvacPercent equals 100, max_old_reserve is limited only by mutator_xfer_limit and young_reserve + const size_t bound_on_old_reserve = ((old_available + mutator_xfer_limit + young_reserve) * ShenandoahOldEvacPercent) / 100; + size_t proposed_max_old = ((ShenandoahOldEvacPercent == 100)? + bound_on_old_reserve: + MIN2((young_reserve * ShenandoahOldEvacPercent) / (100 - ShenandoahOldEvacPercent), + bound_on_old_reserve)); + if (young_reserve > young_available) { + young_reserve = young_available; + } + // Decide how much old space we should reserve for a mixed collection - double reserve_for_mixed = 0; - if (old_generation()->has_unprocessed_collection_candidates()) { + size_t reserve_for_mixed = 0; + const size_t old_fragmented_available = + old_available - (old_generation()->free_unaffiliated_regions() + old_trashed_regions) * region_size_bytes; + + if (old_fragmented_available > proposed_max_old) { + // After we've promoted regions in place, there may be an abundance of old-fragmented available memory, + // even more than the desired percentage for old reserve. We cannot transfer these fragmented regions back + // to young. Instead we make the best of the situation by using this fragmented memory for both promotions + // and evacuations. + proposed_max_old = old_fragmented_available; + } + size_t reserve_for_promo = old_fragmented_available; + const size_t max_old_reserve = proposed_max_old; + const size_t mixed_candidate_live_memory = old_generation()->unprocessed_collection_candidates_live_memory(); + const bool doing_mixed = (mixed_candidate_live_memory > 0); + if (doing_mixed) { // We want this much memory to be unfragmented in order to reliably evacuate old. This is conservative because we // may not evacuate the entirety of unprocessed candidates in a single mixed evacuation. - const double max_evac_need = - (double(old_generation()->unprocessed_collection_candidates_live_memory()) * ShenandoahOldEvacWaste); + const size_t max_evac_need = (size_t) (mixed_candidate_live_memory * ShenandoahOldEvacWaste); assert(old_available >= old_generation()->free_unaffiliated_regions() * region_size_bytes, "Unaffiliated available must be less than total available"); - const double old_fragmented_available = - double(old_available - old_generation()->free_unaffiliated_regions() * region_size_bytes); - reserve_for_mixed = max_evac_need + old_fragmented_available; - if (reserve_for_mixed > max_old_reserve) { - reserve_for_mixed = max_old_reserve; + + // We prefer to evacuate all of mixed into unfragmented memory, and will expand old in order to do so, unless + // we already have too much fragmented available memory in old. + reserve_for_mixed = max_evac_need; + if (reserve_for_mixed + reserve_for_promo > max_old_reserve) { + // In this case, we'll allow old-evac to target some of the fragmented old memory. + size_t excess_reserves = (reserve_for_mixed + reserve_for_promo) - max_old_reserve; + if (reserve_for_promo > excess_reserves) { + reserve_for_promo -= excess_reserves; + } else { + excess_reserves -= reserve_for_promo; + reserve_for_promo = 0; + reserve_for_mixed -= excess_reserves; + } } } - // Decide how much space we should reserve for promotions from young - size_t reserve_for_promo = 0; + // Decide how much additional space we should reserve for promotions from young. We give priority to mixed evacations + // over promotions. const size_t promo_load = old_generation()->get_promotion_potential(); const bool doing_promotions = promo_load > 0; if (doing_promotions) { - // We're promoting and have a bound on the maximum amount that can be promoted - assert(max_old_reserve >= reserve_for_mixed, "Sanity"); - const size_t available_for_promotions = max_old_reserve - reserve_for_mixed; - reserve_for_promo = MIN2((size_t)(promo_load * ShenandoahPromoEvacWaste), available_for_promotions); + // We've already set aside all of the fragmented available memory within old-gen to represent old objects + // to be promoted from young generation. promo_load represents the memory that we anticipate to be promoted + // from regions that have reached tenure age. In the ideal, we will always use fragmented old-gen memory + // to hold individually promoted objects and will use unfragmented old-gen memory to represent the old-gen + // evacuation workloa. + + // We're promoting and have an estimate of memory to be promoted from aged regions + assert(max_old_reserve >= (reserve_for_mixed + reserve_for_promo), "Sanity"); + const size_t available_for_additional_promotions = max_old_reserve - (reserve_for_mixed + reserve_for_promo); + size_t promo_need = (size_t)(promo_load * ShenandoahPromoEvacWaste); + if (promo_need > reserve_for_promo) { + reserve_for_promo += MIN2(promo_need - reserve_for_promo, available_for_additional_promotions); + } + // We've already reserved all the memory required for the promo_load, and possibly more. The excess + // can be consumed by objects promoted from regions that have not yet reached tenure age. } - // This is the total old we want to ideally reserve - const size_t old_reserve = reserve_for_mixed + reserve_for_promo; - assert(old_reserve <= max_old_reserve, "cannot reserve more than max for old evacuations"); + // This is the total old we want to reserve (initialized to the ideal reserve) + size_t old_reserve = reserve_for_mixed + reserve_for_promo; // We now check if the old generation is running a surplus or a deficit. - const size_t max_old_available = old_generation()->available() + old_cset_regions * region_size_bytes; - if (max_old_available >= old_reserve) { - // We are running a surplus, so the old region surplus can go to young - const size_t old_surplus = (max_old_available - old_reserve) / region_size_bytes; - const size_t unaffiliated_old_regions = old_generation()->free_unaffiliated_regions() + old_cset_regions; - const size_t old_region_surplus = MIN2(old_surplus, unaffiliated_old_regions); - old_generation()->set_region_balance(checked_cast(old_region_surplus)); - } else { - // We are running a deficit which we'd like to fill from young. - // Ignore that this will directly impact young_generation()->max_capacity(), - // indirectly impacting young_reserve and old_reserve. These computations are conservative. - // Note that deficit is rounded up by one region. - const size_t old_need = (old_reserve - max_old_available + region_size_bytes - 1) / region_size_bytes; - const size_t max_old_region_xfer = old_xfer_limit / region_size_bytes; + size_t old_region_deficit = 0; + size_t old_region_surplus = 0; - // Round down the regions we can transfer from young to old. If we're running short - // on young-gen memory, we restrict the xfer. Old-gen collection activities will be - // curtailed if the budget is restricted. - const size_t old_region_deficit = MIN2(old_need, max_old_region_xfer); + size_t mutator_region_xfer_limit = mutator_xfer_limit / region_size_bytes; + // align the mutator_xfer_limit on region size + mutator_xfer_limit = mutator_region_xfer_limit * region_size_bytes; + + if (old_available >= old_reserve) { + // We are running a surplus, so the old region surplus can go to young + const size_t old_surplus = old_available - old_reserve; + old_region_surplus = old_surplus / region_size_bytes; + const size_t unaffiliated_old_regions = old_generation()->free_unaffiliated_regions() + old_trashed_regions; + old_region_surplus = MIN2(old_region_surplus, unaffiliated_old_regions); + old_generation()->set_region_balance(checked_cast(old_region_surplus)); + } else if (old_available + mutator_xfer_limit >= old_reserve) { + // Mutator's xfer limit is sufficient to satisfy our need: transfer all memory from there + size_t old_deficit = old_reserve - old_available; + old_region_deficit = (old_deficit + region_size_bytes - 1) / region_size_bytes; + old_generation()->set_region_balance(0 - checked_cast(old_region_deficit)); + } else { + // We'll try to xfer from both mutator excess and from young collector reserve + size_t available_reserves = old_available + young_reserve + mutator_xfer_limit; + size_t old_entitlement = (available_reserves * ShenandoahOldEvacPercent) / 100; + + // Round old_entitlement down to nearest multiple of regions to be transferred to old + size_t entitled_xfer = old_entitlement - old_available; + entitled_xfer = region_size_bytes * (entitled_xfer / region_size_bytes); + size_t unaffiliated_young_regions = young_generation()->free_unaffiliated_regions(); + size_t unaffiliated_young_memory = unaffiliated_young_regions * region_size_bytes; + if (entitled_xfer > unaffiliated_young_memory) { + entitled_xfer = unaffiliated_young_memory; + } + old_entitlement = old_available + entitled_xfer; + if (old_entitlement < old_reserve) { + // There's not enough memory to satisfy our desire. Scale back our old-gen intentions. + size_t budget_overrun = old_reserve - old_entitlement;; + if (reserve_for_promo > budget_overrun) { + reserve_for_promo -= budget_overrun; + old_reserve -= budget_overrun; + } else { + budget_overrun -= reserve_for_promo; + reserve_for_promo = 0; + reserve_for_mixed = (reserve_for_mixed > budget_overrun)? reserve_for_mixed - budget_overrun: 0; + old_reserve = reserve_for_promo + reserve_for_mixed; + } + } + + // Because of adjustments above, old_reserve may be smaller now than it was when we tested the branch + // condition above: "(old_available + mutator_xfer_limit >= old_reserve) + // Therefore, we do NOT know that: mutator_xfer_limit < old_reserve - old_available + + size_t old_deficit = old_reserve - old_available; + old_region_deficit = (old_deficit + region_size_bytes - 1) / region_size_bytes; + + // Shrink young_reserve to account for loan to old reserve + const size_t reserve_xfer_regions = old_region_deficit - mutator_region_xfer_limit; + young_reserve -= reserve_xfer_regions * region_size_bytes; old_generation()->set_region_balance(0 - checked_cast(old_region_deficit)); } -} -void ShenandoahGenerationalHeap::reset_generation_reserves() { - ShenandoahHeapLocker locker(lock()); - young_generation()->set_evacuation_reserve(0); - old_generation()->set_evacuation_reserve(0); - old_generation()->set_promoted_reserve(0); + assert(old_region_deficit == 0 || old_region_surplus == 0, "Only surplus or deficit, never both"); + assert(young_reserve + reserve_for_mixed + reserve_for_promo <= old_available + young_available, + "Cannot reserve more memory than is available: %zu + %zu + %zu <= %zu + %zu", + young_reserve, reserve_for_mixed, reserve_for_promo, old_available, young_available); + + // deficit/surplus adjustments to generation sizes will precede rebuild + young_generation()->set_evacuation_reserve(young_reserve); + old_generation()->set_evacuation_reserve(reserve_for_mixed); + old_generation()->set_promoted_reserve(reserve_for_promo); } void ShenandoahGenerationalHeap::coalesce_and_fill_old_regions(bool concurrent) { @@ -1015,10 +1104,6 @@ void ShenandoahGenerationalHeap::final_update_refs_update_region_states() { void ShenandoahGenerationalHeap::complete_degenerated_cycle() { shenandoah_assert_heaplocked_or_safepoint(); - // In case degeneration interrupted concurrent evacuation or update references, we need to clean up - // transient state. Otherwise, these actions have no effect. - reset_generation_reserves(); - if (!old_generation()->is_parsable()) { ShenandoahGCPhase phase(ShenandoahPhaseTimings::degen_gc_coalesce_and_fill); coalesce_and_fill_old_regions(false); @@ -1036,7 +1121,6 @@ void ShenandoahGenerationalHeap::complete_concurrent_cycle() { // throw off the heuristics. entry_global_coalesce_and_fill(); } - reset_generation_reserves(); } void ShenandoahGenerationalHeap::entry_global_coalesce_and_fill() { diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.hpp b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.hpp index a2ae4a68cd0..719bae52a83 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.hpp @@ -136,7 +136,7 @@ public: void reset_generation_reserves(); // Computes the optimal size for the old generation, represented as a surplus or deficit of old regions - void compute_old_generation_balance(size_t old_xfer_limit, size_t old_cset_regions); + void compute_old_generation_balance(size_t old_xfer_limit, size_t old_trashed_regions, size_t young_trashed_regions); // Balances generations, coalesces and fills old regions if necessary void complete_degenerated_cycle(); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp index 683e2959a92..ef99bd98c93 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp @@ -425,20 +425,29 @@ jint ShenandoahHeap::initialize() { _affiliations[i] = ShenandoahAffiliation::FREE; } + + if (mode()->is_generational()) { + size_t young_reserve = (soft_max_capacity() * ShenandoahEvacReserve) / 100; + young_generation()->set_evacuation_reserve(young_reserve); + old_generation()->set_evacuation_reserve((size_t) 0); + old_generation()->set_promoted_reserve((size_t) 0); + } + _free_set = new ShenandoahFreeSet(this, _num_regions); post_initialize_heuristics(); + // We are initializing free set. We ignore cset region tallies. - size_t young_cset_regions, old_cset_regions, first_old, last_old, num_old; - _free_set->prepare_to_rebuild(young_cset_regions, old_cset_regions, first_old, last_old, num_old); + size_t young_trashed_regions, old_trashed_regions, first_old, last_old, num_old; + _free_set->prepare_to_rebuild(young_trashed_regions, old_trashed_regions, first_old, last_old, num_old); if (mode()->is_generational()) { ShenandoahGenerationalHeap* gen_heap = ShenandoahGenerationalHeap::heap(); // We cannot call // gen_heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(young_cset_regions) // until after the heap is fully initialized. So we make up a safe value here. size_t allocation_runway = InitialHeapSize / 2; - gen_heap->compute_old_generation_balance(allocation_runway, old_cset_regions); + gen_heap->compute_old_generation_balance(allocation_runway, old_trashed_regions, young_trashed_regions); } - _free_set->finish_rebuild(young_cset_regions, old_cset_regions, num_old); + _free_set->finish_rebuild(young_trashed_regions, old_trashed_regions, num_old); } if (AlwaysPreTouch) { @@ -2521,13 +2530,10 @@ void ShenandoahHeap::final_update_refs_update_region_states() { parallel_heap_region_iterate(&cl); } -void ShenandoahHeap::rebuild_free_set(bool concurrent) { - ShenandoahGCPhase phase(concurrent ? - ShenandoahPhaseTimings::final_update_refs_rebuild_freeset : - ShenandoahPhaseTimings::degen_gc_final_update_refs_rebuild_freeset); +void ShenandoahHeap::rebuild_free_set_within_phase() { ShenandoahHeapLocker locker(lock()); - size_t young_cset_regions, old_cset_regions, first_old_region, last_old_region, old_region_count; - _free_set->prepare_to_rebuild(young_cset_regions, old_cset_regions, first_old_region, last_old_region, old_region_count); + size_t young_trashed_regions, old_trashed_regions, first_old_region, last_old_region, old_region_count; + _free_set->prepare_to_rebuild(young_trashed_regions, old_trashed_regions, first_old_region, last_old_region, old_region_count); // If there are no old regions, first_old_region will be greater than last_old_region assert((first_old_region > last_old_region) || ((last_old_region + 1 - first_old_region >= old_region_count) && @@ -2546,19 +2552,11 @@ void ShenandoahHeap::rebuild_free_set(bool concurrent) { // available for transfer to old. Note that transfer of humongous regions does not impact available. ShenandoahGenerationalHeap* gen_heap = ShenandoahGenerationalHeap::heap(); size_t allocation_runway = - gen_heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(young_cset_regions); - gen_heap->compute_old_generation_balance(allocation_runway, old_cset_regions); - - // Total old_available may have been expanded to hold anticipated promotions. We trigger if the fragmented available - // memory represents more than 16 regions worth of data. Note that fragmentation may increase when we promote regular - // regions in place when many of these regular regions have an abundant amount of available memory within them. - // Fragmentation will decrease as promote-by-copy consumes the available memory within these partially consumed regions. - // - // We consider old-gen to have excessive fragmentation if more than 12.5% of old-gen is free memory that resides - // within partially consumed regions of memory. + gen_heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(young_trashed_regions); + gen_heap->compute_old_generation_balance(allocation_runway, old_trashed_regions, young_trashed_regions); } // Rebuild free set based on adjusted generation sizes. - _free_set->finish_rebuild(young_cset_regions, old_cset_regions, old_region_count); + _free_set->finish_rebuild(young_trashed_regions, old_trashed_regions, old_region_count); if (mode()->is_generational()) { ShenandoahGenerationalHeap* gen_heap = ShenandoahGenerationalHeap::heap(); @@ -2567,6 +2565,13 @@ void ShenandoahHeap::rebuild_free_set(bool concurrent) { } } +void ShenandoahHeap::rebuild_free_set(bool concurrent) { + ShenandoahGCPhase phase(concurrent ? + ShenandoahPhaseTimings::final_update_refs_rebuild_freeset : + ShenandoahPhaseTimings::degen_gc_final_update_refs_rebuild_freeset); + rebuild_free_set_within_phase(); +} + bool ShenandoahHeap::is_bitmap_slice_committed(ShenandoahHeapRegion* r, bool skip_self) { size_t slice = r->index() / _bitmap_regions_per_slice; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp index 65e3803627c..174001170f4 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp @@ -481,7 +481,9 @@ private: void rendezvous_threads(const char* name); void recycle_trash(); public: + // The following two functions rebuild the free set at the end of GC, in preparation for an idle phase. void rebuild_free_set(bool concurrent); + void rebuild_free_set_within_phase(); void notify_gc_progress(); void notify_gc_no_progress(); size_t get_gc_no_progress_count() const; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeapRegion.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeapRegion.cpp index e794a86e473..6bb8382de0a 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeapRegion.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeapRegion.cpp @@ -595,6 +595,8 @@ void ShenandoahHeapRegion::try_recycle_under_lock() { _recycling.unset(); } else { // Ensure recycling is unset before returning to mutator to continue memory allocation. + // Otherwise, the mutator might see region as fully recycled and might change its affiliation only to have + // the racing GC worker thread overwrite its affiliation to FREE. while (_recycling.is_set()) { if (os::is_MP()) { SpinPause(); @@ -605,6 +607,8 @@ void ShenandoahHeapRegion::try_recycle_under_lock() { } } +// Note that return from try_recycle() does not mean the region has been recycled. It only means that +// some GC worker thread has taken responsibility to recycle the region, eventually. void ShenandoahHeapRegion::try_recycle() { shenandoah_assert_not_heaplocked(); if (is_trash() && _recycling.try_set()) { diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp index a44a831ef3d..ff441a0c868 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp @@ -128,8 +128,6 @@ bool ShenandoahOldGC::collect(GCCause::Cause cause) { // the space. This would be the last action if there is nothing to evacuate. entry_cleanup_early(); - heap->free_set()->log_status_under_lock(); - assert(!heap->is_concurrent_strong_root_in_progress(), "No evacuations during old gc."); // We must execute this vm operation if we completed final mark. We cannot @@ -138,7 +136,10 @@ bool ShenandoahOldGC::collect(GCCause::Cause cause) { // collection. heap->concurrent_final_roots(); - size_t allocation_runway = heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(0); - heap->compute_old_generation_balance(allocation_runway, 0); + // After concurrent old marking finishes, we reclaim immediate garbage. Further, we may also want to expand OLD in order + // to make room for anticipated promotions and/or for mixed evacuations. Mixed evacuations are especially likely to + // follow the end of OLD marking. + heap->rebuild_free_set_within_phase(); + heap->free_set()->log_status_under_lock(); return true; } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp index c795eda3d96..aed768b9db1 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp @@ -427,8 +427,7 @@ void ShenandoahOldGeneration::prepare_regions_and_collection_set(bool concurrent ShenandoahGenerationalHeap* gen_heap = ShenandoahGenerationalHeap::heap(); size_t allocation_runway = gen_heap->young_generation()->heuristics()->bytes_of_allocation_runway_before_gc_trigger(young_trash_regions); - gen_heap->compute_old_generation_balance(allocation_runway, old_trash_regions); - + gen_heap->compute_old_generation_balance(allocation_runway, old_trash_regions, young_trash_regions); heap->free_set()->finish_rebuild(young_trash_regions, old_trash_regions, num_old); } } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp index 90c1458ac97..633d2c9f617 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp @@ -66,8 +66,8 @@ private: // remaining in a PLAB when it is retired. size_t _promoted_expended; - // Represents the quantity of live bytes we expect to promote during the next evacuation - // cycle. This value is used by the young heuristic to trigger mixed collections. + // Represents the quantity of live bytes we expect to promote during the next GC cycle, either by + // evacuation or by promote-in-place. This value is used by the young heuristic to trigger mixed collections. // It is also used when computing the optimum size for the old generation. size_t _promotion_potential; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.cpp b/src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.cpp index a3c96a7d53b..05af25f13ad 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.cpp @@ -243,8 +243,7 @@ HeapWord* ShenandoahCardCluster::first_object_start(const size_t card_index, con #ifdef ASSERT assert(ShenandoahHeap::heap()->mode()->is_generational(), "Do not use in non-generational mode"); assert(region->is_old(), "Do not use for young regions"); - // For HumongousRegion:s it's more efficient to jump directly to the - // start region. + // For humongous regions it's more efficient to jump directly to the start region. assert(!region->is_humongous(), "Use region->humongous_start_region() instead"); #endif diff --git a/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp b/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp index 543df2422c0..0cc6d4c6ed4 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp @@ -420,7 +420,14 @@ public: // span is the total memory affiliated with these stats (some of which is in use and other is available) size_t span() const { return _regions * ShenandoahHeapRegion::region_size_bytes(); } - size_t non_trashed_span() const { return (_regions - _trashed_regions) * ShenandoahHeapRegion::region_size_bytes(); } + size_t non_trashed_span() const { + assert(_regions >= _trashed_regions, "sanity"); + return (_regions - _trashed_regions) * ShenandoahHeapRegion::region_size_bytes(); + } + size_t non_trashed_committed() const { + assert(_committed >= _trashed_regions * ShenandoahHeapRegion::region_size_bytes(), "sanity"); + return _committed - (_trashed_regions * ShenandoahHeapRegion::region_size_bytes()); + } }; class ShenandoahGenerationStatsClosure : public ShenandoahHeapRegionClosure { diff --git a/src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp b/src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp index 254483d1923..3eb1a06a911 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoah_globals.hpp @@ -400,27 +400,20 @@ "reserve/waste is incorrect, at the risk that application " \ "runs out of memory too early.") \ \ - product(uintx, ShenandoahOldEvacRatioPercent, 75, EXPERIMENTAL, \ - "The maximum proportion of evacuation from old-gen memory, " \ - "expressed as a percentage. The default value 75 denotes that " \ - "no more than 75% of the collection set evacuation workload may " \ - "be towards evacuation of old-gen heap regions. This limits both "\ - "the promotion of aged regions and the compaction of existing " \ - "old regions. A value of 75 denotes that the total evacuation " \ - "work may increase to up to four times the young gen evacuation " \ - "work. A larger value allows quicker promotion and allows " \ - "a smaller number of mixed evacuations to process " \ - "the entire list of old-gen collection candidates at the cost " \ - "of an increased disruption of the normal cadence of young-gen " \ - "collections. A value of 100 allows a mixed evacuation to " \ - "focus entirely on old-gen memory, allowing no young-gen " \ - "regions to be collected, likely resulting in subsequent " \ - "allocation failures because the allocation pool is not " \ - "replenished. A value of 0 allows a mixed evacuation to " \ - "focus entirely on young-gen memory, allowing no old-gen " \ - "regions to be collected, likely resulting in subsequent " \ - "promotion failures and triggering of stop-the-world full GC " \ - "events.") \ + product(uintx, ShenandoahOldEvacPercent, 75, EXPERIMENTAL, \ + "The maximum evacuation to old-gen expressed as a percent of " \ + "the total live memory within the collection set. With the " \ + "default setting, if collection set evacuates X, no more than " \ + "75% of X may hold objects evacuated from old or promoted to " \ + "old from young. A value of 100 allows the entire collection " \ + "set to be comprised of old-gen regions and young regions that " \ + "have reached the tenure age. Larger values allow fewer mixed " \ + "evacuations to reclaim all the garbage from old. Smaller " \ + "values result in less variation in GC cycle times between " \ + "young vs. mixed cycles. A value of 0 prevents mixed " \ + "evacations from running and blocks promotion of aged regions " \ + "by evacuation. Setting the value to 0 does not prevent " \ + "regions from being promoted in place.") \ range(0,100) \ \ product(bool, ShenandoahEvacTracking, false, DIAGNOSTIC, \ diff --git a/test/hotspot/gtest/gc/shenandoah/test_shenandoahOldHeuristic.cpp b/test/hotspot/gtest/gc/shenandoah/test_shenandoahOldHeuristic.cpp index b184b19ce6c..c0ec1bcf3c9 100644 --- a/test/hotspot/gtest/gc/shenandoah/test_shenandoahOldHeuristic.cpp +++ b/test/hotspot/gtest/gc/shenandoah/test_shenandoahOldHeuristic.cpp @@ -201,7 +201,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, prime_one_old_region) { size_t garbage = make_garbage_above_collection_threshold(10); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(10UL)); EXPECT_EQ(garbage, _collection_set->get_old_garbage()); @@ -214,7 +216,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, prime_many_old_regions) { size_t g1 = make_garbage_above_collection_threshold(100); size_t g2 = make_garbage_above_collection_threshold(101); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(100UL, 101UL)); EXPECT_EQ(g1 + g2, _collection_set->get_old_garbage()); @@ -226,7 +230,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, require_multiple_mixed_evacuations) { size_t garbage = create_too_much_garbage_for_one_mixed_evacuation(); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_LT(_collection_set->get_old_garbage(), garbage); EXPECT_GT(_heuristics->unprocessed_old_collection_candidates(), 0UL); @@ -248,7 +254,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, skip_pinned_regions) { ASSERT_EQ(3UL, _heuristics->unprocessed_old_collection_candidates()); // Here the region is still pinned, so it cannot be added to the collection set. - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } // The two unpinned regions should be added to the collection set and the pinned // region should be retained at the front of the list of candidates as it would be @@ -261,7 +269,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, skip_pinned_regions) { // the now unpinned region should be added to the collection set. make_unpinned(1); _collection_set->clear(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_EQ(_collection_set->get_old_garbage(), g2); EXPECT_TRUE(collection_set_is(1UL)); @@ -278,14 +288,18 @@ TEST_VM_F(ShenandoahOldHeuristicTest, pinned_region_is_first) { make_pinned(0); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(1UL, 2UL)); EXPECT_EQ(_heuristics->unprocessed_old_collection_candidates(), 1UL); make_unpinned(0); _collection_set->clear(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(0UL)); EXPECT_EQ(_heuristics->unprocessed_old_collection_candidates(), 0UL); @@ -301,7 +315,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, pinned_region_is_last) { make_pinned(2); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(0UL, 1UL)); EXPECT_EQ(_collection_set->get_old_garbage(), g1 + g2); @@ -309,7 +325,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, pinned_region_is_last) { make_unpinned(2); _collection_set->clear(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(2UL)); EXPECT_EQ(_collection_set->get_old_garbage(), g3); @@ -327,7 +345,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, unpinned_region_is_middle) { make_pinned(0); make_pinned(2); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(1UL)); EXPECT_EQ(_collection_set->get_old_garbage(), g2); @@ -336,7 +356,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, unpinned_region_is_middle) { make_unpinned(0); make_unpinned(2); _collection_set->clear(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } EXPECT_TRUE(collection_set_is(0UL, 2UL)); EXPECT_EQ(_collection_set->get_old_garbage(), g1 + g3); @@ -354,7 +376,9 @@ TEST_VM_F(ShenandoahOldHeuristicTest, all_candidates_are_pinned) { make_pinned(1); make_pinned(2); _heuristics->prepare_for_old_collections(); - _heuristics->prime_collection_set(_collection_set); + if (_heuristics->prime_collection_set(_collection_set)) { + _heuristics->finalize_mixed_evacs(); + } // In the case when all candidates are pinned, we want to abandon // this set of mixed collection candidates so that another old collection From 25d2b52ab97d116024872e567c1c1ffd814616d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Jeli=C5=84ski?= Date: Thu, 22 Jan 2026 21:48:28 +0000 Subject: [PATCH 014/105] 8328046: Need to keep leading zeros in TlsPremasterSecret of TLS1.3 DHKeyAgreement Reviewed-by: hchao --- .../share/classes/sun/security/ssl/KAKeyDerivation.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/java.base/share/classes/sun/security/ssl/KAKeyDerivation.java b/src/java.base/share/classes/sun/security/ssl/KAKeyDerivation.java index 39e82b50435..af62faf4706 100644 --- a/src/java.base/share/classes/sun/security/ssl/KAKeyDerivation.java +++ b/src/java.base/share/classes/sun/security/ssl/KAKeyDerivation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -214,13 +214,13 @@ public class KAKeyDerivation implements SSLKeyDerivation { var decapsulator = kem.newDecapsulator(localPrivateKey); sharedSecret = decapsulator.decapsulate( keyshare, 0, decapsulator.secretSize(), - "TlsPremasterSecret"); + "Generic"); } else { // Using traditional DH-style Key Agreement KeyAgreement ka = KeyAgreement.getInstance(algorithmName); ka.init(localPrivateKey); ka.doPhase(peerPublicKey, true); - sharedSecret = ka.generateSecret("TlsPremasterSecret"); + sharedSecret = ka.generateSecret("Generic"); } return deriveHandshakeSecret(type, sharedSecret); From 0f087a7fef2d3979badefde02a1e85351379f18c Mon Sep 17 00:00:00 2001 From: SendaoYan Date: Fri, 23 Jan 2026 00:57:25 +0000 Subject: [PATCH 015/105] 8376051: gc/stress/TestStressG1Uncommit.java fails assertLessThan: expected that xxx < xxx Reviewed-by: tschatzl, shade --- test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java b/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java index 9d1f95aa411..4e2b9dd5be7 100644 --- a/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java +++ b/test/hotspot/jtreg/gc/stress/TestStressG1Uncommit.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -55,6 +55,8 @@ public class TestStressG1Uncommit { public static void main(String[] args) throws Exception { ArrayList options = new ArrayList<>(); Collections.addAll(options, + "-XX:MinHeapFreeRatio=40", + "-XX:MaxHeapFreeRatio=70", "-Xlog:gc,gc+heap+region=debug", "-XX:+UseG1GC", "-Xmx1g", From 7f2aa59f8220f302a3f8662eeca3291dcf86d2ad Mon Sep 17 00:00:00 2001 From: Ioi Lam Date: Fri, 23 Jan 2026 06:24:47 +0000 Subject: [PATCH 016/105] 8375654: Exclude all array classes from dynamic CDS archive Reviewed-by: kvn, vlivanov --- src/hotspot/share/cds/archiveBuilder.cpp | 7 +- test/hotspot/jtreg/ProblemList-AotJdk.txt | 29 ++++++++ .../appcds/dynamicArchive/ArraySuperTest.java | 73 +++++++++++++++++++ 3 files changed, 108 insertions(+), 1 deletion(-) create mode 100644 test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/ArraySuperTest.java diff --git a/src/hotspot/share/cds/archiveBuilder.cpp b/src/hotspot/share/cds/archiveBuilder.cpp index 6bbefea5cd9..328bed1ccfb 100644 --- a/src/hotspot/share/cds/archiveBuilder.cpp +++ b/src/hotspot/share/cds/archiveBuilder.cpp @@ -571,7 +571,12 @@ ArchiveBuilder::FollowMode ArchiveBuilder::get_follow_mode(MetaspaceClosure::Ref } if (is_excluded(klass)) { ResourceMark rm; - log_debug(cds, dynamic)("Skipping class (excluded): %s", klass->external_name()); + aot_log_trace(aot)("pointer set to null: class (excluded): %s", klass->external_name()); + return set_to_null; + } + if (klass->is_array_klass() && CDSConfig::is_dumping_dynamic_archive()) { + ResourceMark rm; + aot_log_trace(aot)("pointer set to null: array class not supported in dynamic region: %s", klass->external_name()); return set_to_null; } } diff --git a/test/hotspot/jtreg/ProblemList-AotJdk.txt b/test/hotspot/jtreg/ProblemList-AotJdk.txt index af3994289df..e27e85645f5 100644 --- a/test/hotspot/jtreg/ProblemList-AotJdk.txt +++ b/test/hotspot/jtreg/ProblemList-AotJdk.txt @@ -1,3 +1,32 @@ +# +# Copyright (c) 2024, 2026, 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. +# + +############################################################################# +# +# List of quarantined tests for testing in AOT_JDK mode. +# +############################################################################# + runtime/modules/PatchModule/PatchModuleClassList.java 0000000 generic-all runtime/NMT/NMTWithCDS.java 0000000 generic-all runtime/symbols/TestSharedArchiveConfigFile.java 0000000 generic-all diff --git a/test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/ArraySuperTest.java b/test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/ArraySuperTest.java new file mode 100644 index 00000000000..5274c140f32 --- /dev/null +++ b/test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/ArraySuperTest.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2026, 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 8304147 + * @summary make sure dynamic archive does not archive array classes with incorrect values in + * Array::_secondary_supers + * @requires vm.cds + * @library /test/lib /test/hotspot/jtreg/runtime/cds/appcds + * @build ArraySuperTest jdk.test.whitebox.WhiteBox + * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar ArraySuperApp.jar ArraySuperApp + * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox + * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. ArraySuperTest + */ + +import java.util.function.Predicate; +import jdk.test.lib.helpers.ClassFileInstaller; + +public class ArraySuperTest extends DynamicArchiveTestBase { + + public static void main(String[] args) throws Exception { + runTest(ArraySuperTest::test); + } + + static void test() throws Exception { + String topArchiveName = getNewArchiveName(); + String appJar = ClassFileInstaller.getJarPath("ArraySuperApp.jar"); + String mainClass = ArraySuperApp.class.getName(); + + dump(topArchiveName, "-cp", appJar, mainClass).assertNormalExit(); + run(topArchiveName, "-cp", appJar, "-Xshare:off", mainClass, "withDynamicArchive").assertNormalExit(); + run(topArchiveName, "-cp", appJar, mainClass, "withDynamicArchive").assertNormalExit(); + } +} + +class ArraySuperApp implements Predicate { + static volatile Object array; + public boolean test(Object o) { + return true; + } + static void main(String args[]) { + array = new ArraySuperApp[1]; + if (args.length > 0) { + Predicate[] p = new Predicate[0]; + System.out.println(p.getClass().isInstance(array)); + p = (Predicate[])array; + p[0] = new ArraySuperApp(); + System.out.println("All tests passed"); + } + } +} From 39f0e6d6f91bf7e75862851ca0e00fc62780f938 Mon Sep 17 00:00:00 2001 From: Julian Waters Date: Fri, 23 Jan 2026 07:07:51 +0000 Subject: [PATCH 017/105] 8375241: Simplify --with-native-debug-symbols-level option implementation Reviewed-by: erikj, shade --- make/autoconf/flags-cflags.m4 | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/make/autoconf/flags-cflags.m4 b/make/autoconf/flags-cflags.m4 index 5a9fdc57c74..639c3852212 100644 --- a/make/autoconf/flags-cflags.m4 +++ b/make/autoconf/flags-cflags.m4 @@ -69,22 +69,18 @@ AC_DEFUN([FLAGS_SETUP_DEBUG_SYMBOLS], # Debug prefix mapping if supported by compiler DEBUG_PREFIX_CFLAGS= - UTIL_ARG_WITH(NAME: native-debug-symbols-level, TYPE: string, - DEFAULT: "", - RESULT: DEBUG_SYMBOLS_LEVEL, + UTIL_ARG_WITH(NAME: native-debug-symbols-level, TYPE: literal, + DEFAULT: [auto], VALID_VALUES: [auto 1 2 3], + CHECK_AVAILABLE: [ + if test x$TOOLCHAIN_TYPE = xmicrosoft; then + AVAILABLE=false + fi + ], DESC: [set the native debug symbol level (GCC and Clang only)], - DEFAULT_DESC: [toolchain default]) - AC_SUBST(DEBUG_SYMBOLS_LEVEL) - - if test "x${TOOLCHAIN_TYPE}" = xgcc || \ - test "x${TOOLCHAIN_TYPE}" = xclang; then - DEBUG_SYMBOLS_LEVEL_FLAGS="-g" - if test "x${DEBUG_SYMBOLS_LEVEL}" != "x"; then - DEBUG_SYMBOLS_LEVEL_FLAGS="-g${DEBUG_SYMBOLS_LEVEL}" - FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [${DEBUG_SYMBOLS_LEVEL_FLAGS}], - IF_FALSE: AC_MSG_ERROR("Debug info level ${DEBUG_SYMBOLS_LEVEL} is not supported")) - fi - fi + DEFAULT_DESC: [toolchain default], + IF_AUTO: [ + RESULT="" + ]) # Debug symbols if test "x$TOOLCHAIN_TYPE" = xgcc; then @@ -111,8 +107,8 @@ AC_DEFUN([FLAGS_SETUP_DEBUG_SYMBOLS], fi # Debug info level should follow the debug format to be effective. - CFLAGS_DEBUG_SYMBOLS="-gdwarf-4 ${DEBUG_SYMBOLS_LEVEL_FLAGS}" - ASFLAGS_DEBUG_SYMBOLS="${DEBUG_SYMBOLS_LEVEL_FLAGS}" + CFLAGS_DEBUG_SYMBOLS="-gdwarf-4 -g${NATIVE_DEBUG_SYMBOLS_LEVEL}" + ASFLAGS_DEBUG_SYMBOLS="-g${NATIVE_DEBUG_SYMBOLS_LEVEL}" elif test "x$TOOLCHAIN_TYPE" = xclang; then if test "x$ALLOW_ABSOLUTE_PATHS_IN_OUTPUT" = "xfalse"; then # Check if compiler supports -fdebug-prefix-map. If so, use that to make @@ -132,8 +128,8 @@ AC_DEFUN([FLAGS_SETUP_DEBUG_SYMBOLS], IF_FALSE: [GDWARF_FLAGS=""]) # Debug info level should follow the debug format to be effective. - CFLAGS_DEBUG_SYMBOLS="${GDWARF_FLAGS} ${DEBUG_SYMBOLS_LEVEL_FLAGS}" - ASFLAGS_DEBUG_SYMBOLS="${DEBUG_SYMBOLS_LEVEL_FLAGS}" + CFLAGS_DEBUG_SYMBOLS="${GDWARF_FLAGS} -g${NATIVE_DEBUG_SYMBOLS_LEVEL}" + ASFLAGS_DEBUG_SYMBOLS="-g${NATIVE_DEBUG_SYMBOLS_LEVEL}" elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then CFLAGS_DEBUG_SYMBOLS="-Z7" fi From 315bf07b23ad6c5f86fc8fe976abd9e9a8548404 Mon Sep 17 00:00:00 2001 From: Jan Lahoda Date: Fri, 23 Jan 2026 07:40:52 +0000 Subject: [PATCH 018/105] 8375119: SwitchBoostraps.enumSwitch does not throw an NPE when lookup is null in some cases Reviewed-by: liach --- .../java/lang/runtime/SwitchBootstraps.java | 18 ++++++++---- .../lang/runtime/SwitchBootstrapsTest.java | 29 ++++++++++++++++++- 2 files changed, 41 insertions(+), 6 deletions(-) diff --git a/src/java.base/share/classes/java/lang/runtime/SwitchBootstraps.java b/src/java.base/share/classes/java/lang/runtime/SwitchBootstraps.java index 30b6df0073e..087d2cc23a9 100644 --- a/src/java.base/share/classes/java/lang/runtime/SwitchBootstraps.java +++ b/src/java.base/share/classes/java/lang/runtime/SwitchBootstraps.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -188,13 +188,17 @@ public final class SwitchBootstraps { String invocationName, MethodType invocationType, Object... labels) { + requireNonNull(lookup); + requireNonNull(invocationType); + requireNonNull(labels); + Class selectorType = invocationType.parameterType(0); if (invocationType.parameterCount() != 2 || (!invocationType.returnType().equals(int.class)) || !invocationType.parameterType(1).equals(int.class)) throw new IllegalArgumentException("Illegal invocation type " + invocationType); - for (Object l : labels) { // implicit null-check + for (Object l : labels) { verifyLabel(l, selectorType); } @@ -292,6 +296,10 @@ public final class SwitchBootstraps { String invocationName, MethodType invocationType, Object... labels) { + requireNonNull(lookup); + requireNonNull(invocationType); + requireNonNull(labels); + if (invocationType.parameterCount() != 2 || (!invocationType.returnType().equals(int.class)) || invocationType.parameterType(0).isPrimitive() @@ -299,7 +307,7 @@ public final class SwitchBootstraps { || !invocationType.parameterType(1).equals(int.class)) throw new IllegalArgumentException("Illegal invocation type " + invocationType); - labels = labels.clone(); // implicit null check + labels = labels.clone(); Class enumClass = invocationType.parameterType(0); boolean constantsOnly = true; @@ -307,7 +315,7 @@ public final class SwitchBootstraps { for (int i = 0; i < len; i++) { Object convertedLabel = - convertEnumConstants(lookup, enumClass, labels[i]); + convertEnumConstants(enumClass, labels[i]); labels[i] = convertedLabel; if (constantsOnly) constantsOnly = convertedLabel instanceof EnumDesc; @@ -331,7 +339,7 @@ public final class SwitchBootstraps { return new ConstantCallSite(target); } - private static > Object convertEnumConstants(MethodHandles.Lookup lookup, Class enumClassTemplate, Object label) { + private static > Object convertEnumConstants(Class enumClassTemplate, Object label) { if (label == null) { throw new IllegalArgumentException("null label found"); } diff --git a/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java b/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java index 8c6132b2815..3a8608866dc 100644 --- a/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java +++ b/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -447,4 +447,31 @@ public class SwitchBootstrapsTest { }); }); } + + public void testNullLookup() throws Throwable { + try { + MethodType switchType = MethodType.methodType(int.class, Object.class, int.class); + BSM_TYPE_SWITCH.invoke(null, "", switchType, Object.class); + fail("Didn't get the expected exception."); + } catch (NullPointerException ex) { + //OK + } + enum E {} + try { + MethodType switchType = MethodType.methodType(int.class, E.class, int.class); + BSM_ENUM_SWITCH.invoke(null, "", switchType, + new Object[] {}); + fail("Didn't get the expected exception."); + } catch (NullPointerException ex) { + //OK + } + try { + MethodType switchType = MethodType.methodType(int.class, E.class, int.class); + BSM_ENUM_SWITCH.invoke(null, "", switchType, + new Object[] {"A"}); + fail("Didn't get the expected exception."); + } catch (NullPointerException ex) { + //OK + } + } } From ca37dba4d40bf3f71c5489829c893346faec1c56 Mon Sep 17 00:00:00 2001 From: Volkan Yazici Date: Fri, 23 Jan 2026 08:27:27 +0000 Subject: [PATCH 019/105] 8376089: Increase QUIC idle timeout in H3FixedThreadPoolTest to collect more diagnostic Reviewed-by: dfuchs, jpai --- .../net/httpclient/http3/H3FixedThreadPoolTest.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/test/jdk/java/net/httpclient/http3/H3FixedThreadPoolTest.java b/test/jdk/java/net/httpclient/http3/H3FixedThreadPoolTest.java index c513cd092c7..6c181186fda 100644 --- a/test/jdk/java/net/httpclient/http3/H3FixedThreadPoolTest.java +++ b/test/jdk/java/net/httpclient/http3/H3FixedThreadPoolTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, 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 @@ -30,9 +30,17 @@ * jdk.test.lib.Utils * jdk.test.lib.net.SimpleSSLContext * @compile ../ReferenceTracker.java + * + * @comment This test failed on Tier 7, but the failure could not be reproduced. + * The QUIC idle timeout has been increased to a value higher than the + * JTreg on Tier 7 so that, if the client becomes wedged again, the + * JTreg timeout handlers can collect more diagnostic information. + * * @run testng/othervm -Djdk.internal.httpclient.debug=err * -Djdk.httpclient.HttpClient.log=ssl,headers,requests,responses,errors - * H3FixedThreadPoolTest + * -Djdk.httpclient.quic.idleTimeout=666666 + * -Djdk.test.server.quic.idleTimeout=666666 + * ${test.main.class} */ import java.net.URI; From fa20391e73102a5d6a5b0a760d95a4225c673e04 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Fri, 23 Jan 2026 08:31:31 +0000 Subject: [PATCH 020/105] 8375966: G1: Convert G1UpdateRegionLivenessAndSelectForRebuildTask to use Atomic Reviewed-by: kbarrett, shade --- src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.cpp | 5 ++--- src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.hpp | 9 ++++++--- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.cpp b/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.cpp index fdef4214622..4eb11f6d8f6 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -30,7 +30,6 @@ #include "gc/g1/g1HeapRegionPrinter.hpp" #include "gc/g1/g1RemSetTrackingPolicy.hpp" #include "logging/log.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/mutexLocker.hpp" struct G1UpdateRegionLivenessAndSelectForRebuildTask::G1OnRegionClosure : public G1HeapRegionClosure { @@ -154,7 +153,7 @@ void G1UpdateRegionLivenessAndSelectForRebuildTask::work(uint worker_id) { G1OnRegionClosure on_region_cl(_g1h, _cm, &local_cleanup_list); _g1h->heap_region_par_iterate_from_worker_offset(&on_region_cl, &_hrclaimer, worker_id); - AtomicAccess::add(&_total_selected_for_rebuild, on_region_cl._num_selected_for_rebuild); + _total_selected_for_rebuild.add_then_fetch(on_region_cl._num_selected_for_rebuild); // Update the old/humongous region sets _g1h->remove_from_old_gen_sets(on_region_cl._num_old_regions_removed, diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.hpp b/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.hpp index 161f0b4b9f5..a256693ff1d 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMarkRemarkTasks.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -29,6 +29,7 @@ #include "gc/g1/g1HeapRegionManager.hpp" #include "gc/g1/g1HeapRegionSet.hpp" #include "gc/shared/workerThread.hpp" +#include "runtime/atomic.hpp" class G1CollectedHeap; class G1ConcurrentMark; @@ -41,7 +42,7 @@ class G1UpdateRegionLivenessAndSelectForRebuildTask : public WorkerTask { G1ConcurrentMark* _cm; G1HeapRegionClaimer _hrclaimer; - uint volatile _total_selected_for_rebuild; + Atomic _total_selected_for_rebuild; // Reclaimed empty regions G1FreeRegionList _cleanup_list; @@ -57,7 +58,9 @@ public: void work(uint worker_id) override; - uint total_selected_for_rebuild() const { return _total_selected_for_rebuild; } + uint total_selected_for_rebuild() const { + return _total_selected_for_rebuild.load_relaxed(); + } static uint desired_num_workers(uint num_regions); }; From 6f6966b28b2c5a18b001be49f5db429c667d7a8f Mon Sep 17 00:00:00 2001 From: Guanqiang Han Date: Fri, 23 Jan 2026 11:37:30 +0000 Subject: [PATCH 021/105] 8374862: assert(false) failed: Attempting to acquire lock MDOExtraData_lock/nosafepoint-1 out of order with lock tty_lock/tty -- possible deadlock (running with -XX:+Verbose -XX:+WizardMode -XX:+PrintDeoptimizationDetails) Reviewed-by: dholmes, dlong --- .../share/interpreter/bytecodeTracer.cpp | 12 +++--- .../share/interpreter/bytecodeTracer.hpp | 4 +- src/hotspot/share/oops/method.cpp | 10 ++--- src/hotspot/share/oops/method.hpp | 6 +-- src/hotspot/share/runtime/vframeArray.cpp | 15 ++++++- .../TestDeoptDetailsLockRank.java | 39 +++++++++++++++++++ 6 files changed, 69 insertions(+), 17 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/uncommontrap/TestDeoptDetailsLockRank.java diff --git a/src/hotspot/share/interpreter/bytecodeTracer.cpp b/src/hotspot/share/interpreter/bytecodeTracer.cpp index f9980e389e2..69fc93b6c0f 100644 --- a/src/hotspot/share/interpreter/bytecodeTracer.cpp +++ b/src/hotspot/share/interpreter/bytecodeTracer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -192,18 +192,20 @@ void BytecodeTracer::trace_interpreter(const methodHandle& method, address bcp, } #endif -void BytecodeTracer::print_method_codes(const methodHandle& method, int from, int to, outputStream* st, int flags) { +void BytecodeTracer::print_method_codes(const methodHandle& method, int from, int to, outputStream* st, int flags, bool buffered) { BytecodePrinter method_printer(flags); BytecodeStream s(method); s.set_interval(from, to); - // Keep output to st coherent: collect all lines and print at once. ResourceMark rm; stringStream ss; + outputStream* out = buffered ? &ss : st; while (s.next() >= 0) { - method_printer.trace(method, s.bcp(), &ss); + method_printer.trace(method, s.bcp(), out); + } + if (buffered) { + st->print("%s", ss.as_string()); } - st->print("%s", ss.as_string()); } void BytecodePrinter::print_constant(int cp_index, outputStream* st) { diff --git a/src/hotspot/share/interpreter/bytecodeTracer.hpp b/src/hotspot/share/interpreter/bytecodeTracer.hpp index b32e55abbcf..e199a2b7ea2 100644 --- a/src/hotspot/share/interpreter/bytecodeTracer.hpp +++ b/src/hotspot/share/interpreter/bytecodeTracer.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -39,7 +39,7 @@ class BytecodeClosure; class BytecodeTracer: AllStatic { public: NOT_PRODUCT(static void trace_interpreter(const methodHandle& method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st = tty);) - static void print_method_codes(const methodHandle& method, int from, int to, outputStream* st, int flags); + static void print_method_codes(const methodHandle& method, int from, int to, outputStream* st, int flags, bool buffered = true); }; #endif // SHARE_INTERPRETER_BYTECODETRACER_HPP diff --git a/src/hotspot/share/oops/method.cpp b/src/hotspot/share/oops/method.cpp index 1a2e5f0bee4..949441585d8 100644 --- a/src/hotspot/share/oops/method.cpp +++ b/src/hotspot/share/oops/method.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -1898,15 +1898,15 @@ void Method::print_name(outputStream* st) const { #endif // !PRODUCT || INCLUDE_JVMTI -void Method::print_codes_on(outputStream* st, int flags) const { - print_codes_on(0, code_size(), st, flags); +void Method::print_codes_on(outputStream* st, int flags, bool buffered) const { + print_codes_on(0, code_size(), st, flags, buffered); } -void Method::print_codes_on(int from, int to, outputStream* st, int flags) const { +void Method::print_codes_on(int from, int to, outputStream* st, int flags, bool buffered) const { Thread *thread = Thread::current(); ResourceMark rm(thread); methodHandle mh (thread, (Method*)this); - BytecodeTracer::print_method_codes(mh, from, to, st, flags); + BytecodeTracer::print_method_codes(mh, from, to, st, flags, buffered); } CompressedLineNumberReadStream::CompressedLineNumberReadStream(u_char* buffer) : CompressedReadStream(buffer) { diff --git a/src/hotspot/share/oops/method.hpp b/src/hotspot/share/oops/method.hpp index 4592cb8a8c0..add8e59b2be 100644 --- a/src/hotspot/share/oops/method.hpp +++ b/src/hotspot/share/oops/method.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -466,8 +466,8 @@ public: // prints byte codes void print_codes(int flags = 0) const { print_codes_on(tty, flags); } - void print_codes_on(outputStream* st, int flags = 0) const; - void print_codes_on(int from, int to, outputStream* st, int flags = 0) const; + void print_codes_on(outputStream* st, int flags = 0, bool buffered = true) const; + void print_codes_on(int from, int to, outputStream* st, int flags = 0, bool buffered = true) const; // method parameters bool has_method_parameters() const diff --git a/src/hotspot/share/runtime/vframeArray.cpp b/src/hotspot/share/runtime/vframeArray.cpp index a68a0adf299..9f1c082ed8f 100644 --- a/src/hotspot/share/runtime/vframeArray.cpp +++ b/src/hotspot/share/runtime/vframeArray.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -491,6 +491,15 @@ void vframeArrayElement::unpack_on_stack(int caller_actual_parameters, #ifndef PRODUCT if (PrintDeoptimizationDetails) { + const bool print_codes = WizardMode && Verbose; + ResourceMark rm(thread); + stringStream codes_ss; + if (print_codes) { + // print_codes_on() may acquire MDOExtraData_lock (rank nosafepoint-1). + // To keep the lock acquisition order correct, call it before taking tty_lock. + // Avoid double buffering: set buffered=false. + method()->print_codes_on(&codes_ss, 0, false); + } ttyLocker ttyl; tty->print_cr("[%d. Interpreted Frame]", ++unpack_counter); iframe()->print_on(tty); @@ -500,7 +509,9 @@ void vframeArrayElement::unpack_on_stack(int caller_actual_parameters, RegisterMap::WalkContinuation::skip); vframe* f = vframe::new_vframe(iframe(), &map, thread); f->print(); - if (WizardMode && Verbose) method()->print_codes(); + if (print_codes) { + tty->print("%s", codes_ss.as_string()); + } tty->cr(); } #endif // !PRODUCT diff --git a/test/hotspot/jtreg/compiler/uncommontrap/TestDeoptDetailsLockRank.java b/test/hotspot/jtreg/compiler/uncommontrap/TestDeoptDetailsLockRank.java new file mode 100644 index 00000000000..2866a84ba46 --- /dev/null +++ b/test/hotspot/jtreg/compiler/uncommontrap/TestDeoptDetailsLockRank.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2026, 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 8374862 + * @summary Regression test for -XX:+Verbose -XX:+WizardMode -XX:+PrintDeoptimizationDetails crash + * @requires vm.debug + * @run main/othervm -XX:+Verbose -XX:+WizardMode -XX:+PrintDeoptimizationDetails compiler.uncommontrap.TestDeoptDetailsLockRank + */ + +package compiler.uncommontrap; + +public class TestDeoptDetailsLockRank { + + public static void main(String[] args) { + System.out.println("passed"); + } +} \ No newline at end of file From 3fb118a29ed68f2fbb64de45468b0f014fa01890 Mon Sep 17 00:00:00 2001 From: Severin Gehwolf Date: Fri, 23 Jan 2026 16:55:38 +0000 Subject: [PATCH 022/105] 8375692: Hotspot container tests assert with non-ascii vendor name Reviewed-by: naoto, dholmes, syan --- test/hotspot/jtreg/containers/docker/TestJcmd.java | 3 ++- .../platform/docker/TestDockerMemoryMetricsSubgroup.java | 4 +++- test/lib/jdk/test/lib/containers/docker/DockerTestUtils.java | 3 ++- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/test/hotspot/jtreg/containers/docker/TestJcmd.java b/test/hotspot/jtreg/containers/docker/TestJcmd.java index 3cfe2945e92..fcd5c665f2b 100644 --- a/test/hotspot/jtreg/containers/docker/TestJcmd.java +++ b/test/hotspot/jtreg/containers/docker/TestJcmd.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -143,6 +143,7 @@ public class TestJcmd { sb.append(String.format("FROM %s:%s\n", DockerfileConfig.getBaseImageName(), DockerfileConfig.getBaseImageVersion())); sb.append("COPY /jdk /jdk\n"); + sb.append("ENV LANG=C.UTF-8\n"); sb.append("ENV JAVA_HOME=/jdk\n"); if (!IS_PODMAN) { // only needed for docker diff --git a/test/jdk/jdk/internal/platform/docker/TestDockerMemoryMetricsSubgroup.java b/test/jdk/jdk/internal/platform/docker/TestDockerMemoryMetricsSubgroup.java index 7d5dbca6f7c..4b487934169 100644 --- a/test/jdk/jdk/internal/platform/docker/TestDockerMemoryMetricsSubgroup.java +++ b/test/jdk/jdk/internal/platform/docker/TestDockerMemoryMetricsSubgroup.java @@ -91,7 +91,8 @@ public class TestDockerMemoryMetricsSubgroup { .addDockerOpts("--volume", Utils.TEST_JDK + ":/jdk") .addDockerOpts("--privileged") .addDockerOpts("--cgroupns=" + (privateNamespace ? "private" : "host")) - .addDockerOpts("--memory", outerGroupMemorySize); + .addDockerOpts("--memory", outerGroupMemorySize) + .addDockerOpts("-e", "LANG=C.UTF-8"); opts.addClassOptions("mkdir -p /sys/fs/cgroup/memory/test ; " + "echo " + innerSize + " > /sys/fs/cgroup/memory/test/memory.limit_in_bytes ; " + "echo $$ > /sys/fs/cgroup/memory/test/cgroup.procs ; " + @@ -112,6 +113,7 @@ public class TestDockerMemoryMetricsSubgroup { .addDockerOpts("--volume", Utils.TEST_JDK + ":/jdk") .addDockerOpts("--privileged") .addDockerOpts("--cgroupns=" + (privateNamespace ? "private" : "host")) + .addDockerOpts("-e", "LANG=C.UTF-8") .addDockerOpts("--memory", outerGroupMemorySize); opts.addClassOptions("mkdir -p /sys/fs/cgroup/memory/test ; " + "echo $$ > /sys/fs/cgroup/memory/test/cgroup.procs ; " + diff --git a/test/lib/jdk/test/lib/containers/docker/DockerTestUtils.java b/test/lib/jdk/test/lib/containers/docker/DockerTestUtils.java index b013561be0b..bd9a706e3a4 100644 --- a/test/lib/jdk/test/lib/containers/docker/DockerTestUtils.java +++ b/test/lib/jdk/test/lib/containers/docker/DockerTestUtils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -380,6 +380,7 @@ public class DockerTestUtils { } template = template + "COPY /jdk /jdk\n" + "ENV JAVA_HOME=/jdk\n" + + "ENV LANG=C.UTF-8\n" + "CMD [\"/bin/bash\"]\n"; String dockerFileStr = String.format(template, baseImage, baseImageVersion); Files.writeString(dockerfile, dockerFileStr); From 40f7a18b2dbf120a95432174664fa897331e8973 Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Fri, 23 Jan 2026 17:32:53 +0000 Subject: [PATCH 023/105] 8373935: Migrate java/lang/invoke tests away from TestNG Reviewed-by: jvernee, alanb --- .../java/lang/invoke/8147078/Test8147078.java | 23 +- .../invoke/8177146/TestMethodHandleBind.java | 33 +- .../java/lang/invoke/AccessControlTest.java | 57 +-- .../lang/invoke/ArrayConstructorTest.java | 52 +-- .../jdk/java/lang/invoke/ArrayLengthTest.java | 58 +-- .../invoke/CallerSensitiveMethodHandle.java | 13 +- .../lang/invoke/ClassSpecializerTest.java | 15 +- .../invoke/CompileThresholdBootstrapTest.java | 20 +- .../lang/invoke/ConstantIdentityMHTest.java | 30 +- .../jdk/java/lang/invoke/DefineClassTest.java | 73 ++-- .../java/lang/invoke/DropArgumentsTest.java | 39 +- .../java/lang/invoke/DropLookupModeTest.java | 107 +++-- .../java/lang/invoke/FilterArgumentsTest.java | 22 +- test/jdk/java/lang/invoke/FindAccessTest.java | 32 +- test/jdk/java/lang/invoke/FoldTest.java | 18 +- .../java/lang/invoke/InvokeGenericTest.java | 66 +-- .../InvokeMethodHandleWithBadArgument.java | 98 +++-- .../lang/invoke/InvokeWithArgumentsTest.java | 40 +- .../java/lang/invoke/JavaDocExamplesTest.java | 12 +- .../invoke/JavaUtilConcurrentLookupTest.java | 7 +- .../java/lang/invoke/LoopCombinatorTest.java | 384 +++++++++--------- .../lang/invoke/MethodHandleInvokeUOE.java | 8 +- .../invoke/MethodHandleProxies/Driver.java | 4 +- .../invoke/MethodHandleProxies/Unnamed.java | 7 +- .../MethodHandleProxies/m1/module-info.java | 4 +- .../MethodHandleProxies/m1/p1/Main.java | 21 +- .../invoke/MethodHandles/TestDropReturn.java | 20 +- .../invoke/MethodHandles/TestTableSwitch.java | 64 +-- .../classData/ClassDataTest.java | 102 ++--- .../MethodHandles/ensureInitialized/Main.java | 21 +- .../MethodHandles/privateLookupIn/Driver.java | 4 +- .../privateLookupIn/test/module-info.java | 6 +- .../test/p/PrivateLookupInTests.java | 107 +++-- .../invoke/MethodHandlesCollectArgsTest.java | 23 +- .../lang/invoke/MethodHandlesGeneralTest.java | 8 +- test/jdk/java/lang/invoke/MethodTypeTest.java | 48 ++- .../invoke/PermuteArgsReturnVoidTest.java | 18 +- .../jdk/java/lang/invoke/PermuteArgsTest.java | 19 +- .../java/lang/invoke/SpreadCollectTest.java | 102 +++-- .../lang/invoke/TestVHInvokerCaching.java | 16 +- .../java/lang/invoke/ThrowExceptionsTest.java | 23 +- test/jdk/java/lang/invoke/TryFinallyTest.java | 62 ++- test/jdk/java/lang/invoke/VarArgsTest.java | 19 +- .../VarHandleBaseByteArrayTest.java | 11 +- .../invoke/VarHandles/VarHandleBaseTest.java | 47 +-- .../VarHandleMethodReferenceTest.java | 6 +- .../VarHandleTestAccessBoolean.java | 324 ++++++++------- .../VarHandles/VarHandleTestAccessByte.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessChar.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessDouble.java | 252 ++++++------ .../VarHandles/VarHandleTestAccessFloat.java | 252 ++++++------ .../VarHandles/VarHandleTestAccessInt.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessLong.java | 360 ++++++++-------- .../VarHandleTestAccessModeMethodNames.java | 23 +- .../VarHandles/VarHandleTestAccessShort.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessString.java | 216 +++++----- .../VarHandleTestByteArrayAsChar.java | 54 +-- .../VarHandleTestByteArrayAsDouble.java | 98 ++--- .../VarHandleTestByteArrayAsFloat.java | 98 ++--- .../VarHandleTestByteArrayAsInt.java | 146 +++---- .../VarHandleTestByteArrayAsLong.java | 146 +++---- .../VarHandleTestByteArrayAsShort.java | 54 +-- .../invoke/VarHandles/VarHandleTestExact.java | 49 ++- ...arHandleTestMethodHandleAccessBoolean.java | 280 +++++++------ .../VarHandleTestMethodHandleAccessByte.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessChar.java | 316 +++++++------- ...VarHandleTestMethodHandleAccessDouble.java | 208 +++++----- .../VarHandleTestMethodHandleAccessFloat.java | 208 +++++----- .../VarHandleTestMethodHandleAccessInt.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessLong.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessShort.java | 316 +++++++------- ...VarHandleTestMethodHandleAccessString.java | 172 ++++---- .../VarHandleTestMethodTypeBoolean.java | 29 +- .../VarHandleTestMethodTypeByte.java | 29 +- .../VarHandleTestMethodTypeChar.java | 29 +- .../VarHandleTestMethodTypeDouble.java | 29 +- .../VarHandleTestMethodTypeFloat.java | 29 +- .../VarHandleTestMethodTypeInt.java | 29 +- .../VarHandleTestMethodTypeLong.java | 29 +- .../VarHandleTestMethodTypeShort.java | 29 +- .../VarHandleTestMethodTypeString.java | 29 +- .../VarHandles/VarHandleTestReflection.java | 56 +-- .../X-VarHandleTestAccess.java.template | 360 ++++++++-------- ...X-VarHandleTestByteArrayView.java.template | 146 +++---- ...HandleTestMethodHandleAccess.java.template | 316 +++++++------- .../X-VarHandleTestMethodType.java.template | 29 +- .../TestFieldLookupAccessibility.java | 26 +- .../java/lang/invoke/WrongMethodTypeTest.java | 36 +- .../TestAccessClass.java | 24 +- .../TestFindClass.java | 26 +- .../accessClassAndFindClass/TestLookup.java | 14 +- .../CallerSensitiveAccess.java | 142 ++++--- .../condy/BootstrapMethodJumboArgsTest.java | 24 +- .../lang/invoke/condy/CondyBSMException.java | 29 +- .../lang/invoke/condy/CondyBSMInvocation.java | 46 +-- .../invoke/condy/CondyBSMValidationTest.java | 35 +- .../CondyInterfaceWithOverpassMethods.java | 18 +- .../invoke/condy/CondyNameValidationTest.java | 40 +- .../lang/invoke/condy/CondyNestedTest.java | 38 +- .../condy/CondyRepeatFailedResolution.java | 60 ++- .../condy/CondyReturnPrimitiveTest.java | 34 +- .../condy/CondyStaticArgumentsTest.java | 17 +- .../invoke/condy/CondyTypeValidationTest.java | 31 +- .../invoke/condy/CondyWithGarbageTest.java | 17 +- .../lang/invoke/condy/CondyWrongType.java | 45 +- .../invoke/condy/ConstantBootstrapsTest.java | 115 +++--- .../invoke/defineHiddenClass/BasicTest.java | 175 ++++---- .../defineHiddenClass/HiddenNestmateTest.java | 44 +- .../LambdaNestedInnerTest.java | 29 +- .../defineHiddenClass/PreviewHiddenClass.java | 14 +- .../StaticInvocableTest.java | 6 +- .../defineHiddenClass/TypeDescriptorTest.java | 67 ++- .../defineHiddenClass/UnloadingTest.java | 20 +- .../invoke/findSpecial/FindSpecialTest.java | 12 +- .../LambdaFileEncodingSerialization.java | 15 +- .../invoke/lambda/LambdaHiddenCaller.java | 5 +- .../lambda/LogGeneratedClassesTest.java | 76 ++-- .../InvokeSpecialMethodTest.java | 22 +- .../InheritedProtectedMethod.java | 18 +- .../ProtectedMethodInOtherPackage.java | 26 +- .../lang/invoke/lookup/ChainedLookupTest.java | 10 +- .../lang/invoke/lookup/LookupClassTest.java | 30 +- .../lang/invoke/lookup/SpecialStatic.java | 12 +- test/jdk/java/lang/invoke/modules/Driver.java | 6 +- .../jdk/java/lang/invoke/modules/Driver1.java | 6 +- .../lang/invoke/modules/m1/module-info.java | 4 +- .../java/lang/invoke/modules/m1/p1/Main.java | 75 ++-- .../modules/m3/jdk/test/ModuleAccessTest.java | 173 ++++---- .../lang/invoke/modules/m3/module-info.java | 4 +- 129 files changed, 5276 insertions(+), 5487 deletions(-) diff --git a/test/jdk/java/lang/invoke/8147078/Test8147078.java b/test/jdk/java/lang/invoke/8147078/Test8147078.java index 08532d30929..51580aa6f10 100644 --- a/test/jdk/java/lang/invoke/8147078/Test8147078.java +++ b/test/jdk/java/lang/invoke/8147078/Test8147078.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -23,17 +23,18 @@ /* @test * @bug 8147078 - * @run testng/othervm -ea -esa Test8147078 + * @run junit/othervm -ea -esa Test8147078 */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class Test8147078 { @@ -65,16 +66,10 @@ public class Test8147078 { @Test public void testNoExceptionType() { - boolean caught = false; - try { + var cce = assertThrows(ClassCastException.class, () -> { MethodHandle eek = (MethodHandle) MH_catchException.invoke(MH_target, String.class, MH_handler); - } catch (ClassCastException cce) { - assertEquals("java.lang.String", cce.getMessage()); - caught = true; - } catch (Throwable t) { - fail("unexpected exception caught: " + t); - } - assertTrue(caught); + }); + assertEquals("java.lang.String", cce.getMessage()); } } \ No newline at end of file diff --git a/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java b/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java index 134cc9f7514..518d07b1518 100644 --- a/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java +++ b/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, 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 @@ -23,17 +23,16 @@ /* @test * @bug 8177146 - * @run testng/othervm TestMethodHandleBind + * @run junit/othervm TestMethodHandleBind */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.lookup; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class TestMethodHandleBind extends pkg.A { static class B extends TestMethodHandleBind {} @@ -42,7 +41,7 @@ public class TestMethodHandleBind extends pkg.A { public void testInstanceOfCallerClass() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m1", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, this.getClass().getSimpleName()); + assertEquals(this.getClass().getSimpleName(), x); } @Test @@ -50,47 +49,37 @@ public class TestMethodHandleBind extends pkg.A { MethodHandle bound = lookup().bind(new B() , "m1", MethodType.methodType(String.class)); // MethodHandle bound = lookup().findVirtual(B.class, "m1", MethodType.methodType(String.class)).bindTo(new B()); String x = (String)bound.invoke(); - assertEquals(x, "B"); + assertEquals("B", x); } @Test public void testInstanceOfReceiverClass() throws Throwable { - try { - MethodHandle bound = lookup().bind(new pkg.A() , "m1", MethodType.methodType(String.class)); - bound.invoke(); - fail("IllegalAccessException expected"); - } catch (IllegalAccessException e) { - } + assertThrows(IllegalAccessException.class, () -> lookup().bind(new pkg.A() , "m1", MethodType.methodType(String.class))); } @Test public void testPublicMethod() throws Throwable { MethodHandle bound = lookup().bind(new pkg.A() , "m2", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, "A"); + assertEquals("A", x); } @Test public void testPublicMethod2() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind(), "m2", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, this.getClass().getSimpleName()); + assertEquals(this.getClass().getSimpleName(), x); } @Test public void testInstanceOfCallerClassVarargs() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m3", MethodType.methodType(String.class, String[].class)); String x = (String)bound.invoke("a", "b", "c"); - assertEquals(x, this.getClass().getSimpleName() + "abc"); + assertEquals(this.getClass().getSimpleName() + "abc", x); } @Test public void testInstanceOfReceiverClassVarargs() throws Throwable { - try { - MethodHandle bound = lookup().bind(new pkg.A(), "m3", MethodType.methodType(String.class, String[].class)); - bound.invoke(); - fail("IllegalAccessException expected"); - } catch (IllegalAccessException e) { - } + assertThrows(IllegalAccessException.class, () -> lookup().bind(new pkg.A(), "m3", MethodType.methodType(String.class, String[].class))); } } diff --git a/test/jdk/java/lang/invoke/AccessControlTest.java b/test/jdk/java/lang/invoke/AccessControlTest.java index e177f08d876..fcd945a5d7f 100644 --- a/test/jdk/java/lang/invoke/AccessControlTest.java +++ b/test/jdk/java/lang/invoke/AccessControlTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @summary test access checking by java.lang.invoke.MethodHandles.Lookup * @compile AccessControlTest.java AccessControlTest_subpkg/Acquaintance_remote.java - * @run testng/othervm test.java.lang.invoke.AccessControlTest + * @run junit/othervm test.java.lang.invoke.AccessControlTest */ package test.java.lang.invoke; @@ -33,12 +33,13 @@ import java.lang.invoke.*; import java.lang.reflect.*; import java.lang.reflect.Modifier; import java.util.*; -import org.testng.annotations.*; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodHandles.Lookup.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; import test.java.lang.invoke.AccessControlTest_subpkg.Acquaintance_remote; @@ -69,7 +70,7 @@ public class AccessControlTest { this.prevLookupClass = lookup.previousLookupClass(); this.lookupModes = lookup.lookupModes(); - assert(lookupString().equals(lookup.toString())); + assertEquals(lookupString(), lookup.toString()); numberOf(lookupClass().getClassLoader()); // assign CL# } public LookupCase(Class lookupClass, Class prevLookupClass, int lookupModes) { @@ -96,7 +97,7 @@ public class AccessControlTest { int cmp = c1.getName().compareTo(c2.getName()); if (cmp != 0) return cmp; cmp = numberOf(c1.getClassLoader()) - numberOf(c2.getClassLoader()); - assert(cmp != 0); + assertNotEquals(0, cmp); return cmp; } else if (p1 != p2){ if (p1 == null) @@ -106,7 +107,7 @@ public class AccessControlTest { int cmp = p1.getName().compareTo(p2.getName()); if (cmp != 0) return cmp; cmp = numberOf(p1.getClassLoader()) - numberOf(p2.getClassLoader()); - assert(cmp != 0); + assertNotEquals(0, cmp); return cmp; } return -(this.lookupModes() - that.lookupModes()); @@ -211,8 +212,8 @@ public class AccessControlTest { c1.getPackageName().equals(c2.getPackageName())); boolean sameTopLevel = (topLevelClass(c1) == topLevelClass(c2)); boolean sameClass = (c1 == c2); - assert(samePackage || !sameTopLevel); - assert(sameTopLevel || !sameClass); + assertTrue(samePackage || !sameTopLevel); + assertTrue(sameTopLevel || !sameClass); boolean accessible = sameClass; if ((modes1 & PACKAGE) != 0) accessible |= samePackage; @@ -251,17 +252,17 @@ public class AccessControlTest { changed |= (PRIVATE|PROTECTED); // [A5] } if (sameClass) { - assert(changed == 0); // [A11] (no deprivation if same class) + assertEquals(0, changed); // [A11] (no deprivation if same class) } - if (accessible) assert((changed & PUBLIC) == 0); + if (accessible) assertEquals(0, changed & PUBLIC); int modes2 = modes1 & ~changed; Class plc = (m1 == m2) ? prevLookupClass() : c1; // [A9] [A10] if ((modes1 & UNCONDITIONAL) != 0) plc = null; // [A8] LookupCase l2 = new LookupCase(c2, plc, modes2); - assert(l2.lookupClass() == c2); // [A1] - assert((modes1 | modes2) == modes1); // [A1-a] (no elevation of access) - assert(l2.prevLookupClass() == null || (modes2 & MODULE) == 0); + assertSame(l2.lookupClass(), c2); // [A1] + assertEquals(modes1, modes1 | modes2); // [A1-a] (no elevation of access) + assertTrue(l2.prevLookupClass() == null || (modes2 & MODULE) == 0); return l2; } @@ -280,8 +281,8 @@ public class AccessControlTest { } if (newModes == oldModes) return this; // return self if no change LookupCase l2 = new LookupCase(lookupClass(), prevLookupClass(), newModes); - assert((oldModes | newModes) == oldModes); // [A2] (no elevation of access) - assert(l2.prevLookupClass() == null || (newModes & MODULE) == 0); + assertEquals(oldModes, oldModes | newModes); // [A2] (no elevation of access) + assertTrue(l2.prevLookupClass() == null || (newModes & MODULE) == 0); return l2; } @@ -331,7 +332,7 @@ public class AccessControlTest { && Modifier.isPublic(m.getModifiers()); } - assert(m1 == m2 && prevLookupClass == null); + assertNull(prevLookupClass); if (!willAccessClass(c2, false)) return false; @@ -380,7 +381,7 @@ public class AccessControlTest { && Modifier.isPublic(c2.getModifiers()); } - assert(m1 == m2 && prevLookupClass == null); + assertNull(prevLookupClass); LookupCase lc = this.in(c2); int modes1 = lc.lookupModes(); @@ -409,8 +410,8 @@ public class AccessControlTest { Class c = cls; for (Class ec; (ec = c.getEnclosingClass()) != null; ) c = ec; - assert(c.getEnclosingClass() == null); - assert(c == cls || cls.getEnclosingClass() != null); + assertNull(c.getEnclosingClass()); + assertTrue(c == cls || cls.getEnclosingClass() != null); return c; } @@ -443,14 +444,14 @@ public class AccessControlTest { if (edges == null) CASE_EDGES.put(l2, edges = new TreeSet<>()); if (edges.add(l1)) { Class c1 = l1.lookupClass(); - assert(l2.lookupClass() == c2); // [A1] + assertSame(l2.lookupClass(), c2); // [A1] int m1 = l1.lookupModes(); int m2 = l2.lookupModes(); - assert((m1 | m2) == m1); // [A2] (no elevation of access) + assertEquals(m1, (m1 | m2)); // [A2] (no elevation of access) LookupCase expect = dropAccess == 0 ? l1.in(c2) : l1.in(c2).dropLookupMode(dropAccess); if (!expect.equals(l2)) System.out.println("*** expect "+l1+" => "+expect+" but got "+l2); - assertEquals(l2, expect); + assertEquals(expect, l2); } } @@ -567,7 +568,7 @@ public class AccessControlTest { if (willAccess != didAccess) { System.out.println(sourceCase+" => "+targetClass.getSimpleName()+(isFindOrAccessClass?"":"."+methodName+methodType)); System.out.println("fail "+(isFindOrAccessClass?kind:"on "+method)+" ex="+accessError); - assertEquals(willAccess, didAccess); + assertEquals(didAccess, willAccess); } testCount++; if (!didAccess) testCountFails++; @@ -579,10 +580,10 @@ public class AccessControlTest { System.out.println(targetClass.getSimpleName()+"."+methodName+methodType); try { Method method = targetClass.getDeclaredMethod(methodName, methodType.parameterArray()); - assertEquals(method.getReturnType(), methodType.returnType()); + assertEquals(methodType.returnType(), method.getReturnType()); int haveMods = method.getModifiers(); - assert(Modifier.isStatic(haveMods)); - assert(targetAccess == fixMods(haveMods)); + assertTrue(Modifier.isStatic(haveMods)); + assertEquals(targetAccess, fixMods(haveMods)); return method; } catch (NoSuchMethodException ex) { throw new AssertionError(methodName, ex); @@ -604,7 +605,7 @@ public class AccessControlTest { case PACKAGE: return "pkg_in_"; case PRIVATE: return "pri_in_"; } - assert(false); + fail(); return "?"; } private static final int[] ACCESS_CASES = { diff --git a/test/jdk/java/lang/invoke/ArrayConstructorTest.java b/test/jdk/java/lang/invoke/ArrayConstructorTest.java index 749bb7926a0..313c2828380 100644 --- a/test/jdk/java/lang/invoke/ArrayConstructorTest.java +++ b/test/jdk/java/lang/invoke/ArrayConstructorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, 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 @@ -23,7 +23,7 @@ /* @test * @bug 8155106 - * @run testng/othervm -ea -esa test.java.lang.invoke.ArrayConstructorTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ArrayConstructorTest */ package test.java.lang.invoke; @@ -32,30 +32,22 @@ import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; - -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.*; public class ArrayConstructorTest { static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFindConstructorArray() { - boolean caught = false; - try { - MethodHandle h = LOOKUP.findConstructor(Object[].class, methodType(void.class)); - } catch (NoSuchMethodException nsme) { - assertEquals("no constructor for array class: [Ljava.lang.Object;", nsme.getMessage()); - caught = true; - } catch (Exception e) { - throw new AssertionError("unexpected exception: " + e); - } - assertTrue(caught); + public void testFindConstructorArray() { + var nsme = assertThrows(NoSuchMethodException.class, () -> LOOKUP.findConstructor(Object[].class, methodType(void.class))); + assertEquals("no constructor for array class: [Ljava.lang.Object;", nsme.getMessage()); } - @DataProvider static Object[][] arrayConstructorNegative() { return new Object[][]{ {String.class, IllegalArgumentException.class, "not an array class: java.lang.String"}, @@ -63,34 +55,28 @@ public class ArrayConstructorTest { }; } - @Test(dataProvider = "arrayConstructorNegative") - public static void testArrayConstructorNegative(Class clazz, Class exceptionClass, String message) { - boolean caught = false; - try { - MethodHandle h = MethodHandles.arrayConstructor(clazz); - } catch (Exception e) { - assertEquals(exceptionClass, e.getClass()); - if (message != null) { - assertEquals(message, e.getMessage()); - } - caught = true; + @ParameterizedTest + @MethodSource("arrayConstructorNegative") + public void testArrayConstructorNegative(Class clazz, Class exceptionClass, String message) { + var e = assertThrowsExactly(exceptionClass, () -> MethodHandles.arrayConstructor(clazz)); + if (message != null) { + assertEquals(message, e.getMessage()); } - assertTrue(caught); } @Test - public static void testArrayConstructor() throws Throwable { + public void testArrayConstructor() throws Throwable { MethodHandle h = MethodHandles.arrayConstructor(String[].class); assertEquals(methodType(String[].class, int.class), h.type()); String[] a = (String[]) h.invoke(17); assertEquals(17, a.length); } - @Test(expectedExceptions = {NegativeArraySizeException.class}) - public static void testArrayConstructorNegativeIndex() throws Throwable { + @Test + public void testArrayConstructorNegativeIndex() throws Throwable { MethodHandle h = MethodHandles.arrayConstructor(String[].class); assertEquals(methodType(String[].class, int.class), h.type()); - h.invoke(-1); // throws exception + assertThrows(NegativeArraySizeException.class, () -> h.invoke(-1)); } } diff --git a/test/jdk/java/lang/invoke/ArrayLengthTest.java b/test/jdk/java/lang/invoke/ArrayLengthTest.java index 9f3cc6fe240..2ef97442638 100644 --- a/test/jdk/java/lang/invoke/ArrayLengthTest.java +++ b/test/jdk/java/lang/invoke/ArrayLengthTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -22,36 +22,39 @@ */ /* @test - * @run testng/othervm -ea -esa test.java.lang.invoke.ArrayLengthTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ArrayLengthTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class ArrayLengthTest { - @DataProvider - Object[][] arrayClasses() { - return new Object[][] { - {int[].class}, - {long[].class}, - {float[].class}, - {double[].class}, - {boolean[].class}, - {byte[].class}, - {short[].class}, - {char[].class}, - {Object[].class}, - {StringBuffer[].class} + static Object[] arrayClasses() { + return new Object[] { + int[].class, + long[].class, + float[].class, + double[].class, + boolean[].class, + byte[].class, + short[].class, + char[].class, + Object[].class, + StringBuffer[].class }; } - @Test(dataProvider = "arrayClasses") + @ParameterizedTest + @MethodSource("arrayClasses") public void testArrayLength(Class arrayClass) throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(arrayClass); assertEquals(int.class, arrayLength.type().returnType()); @@ -60,25 +63,28 @@ public class ArrayLengthTest { assertEquals(10, arrayLength.invoke(array)); } - @Test(dataProvider = "arrayClasses", expectedExceptions = NullPointerException.class) + @ParameterizedTest + @MethodSource("arrayClasses") public void testArrayLengthInvokeNPE(Class arrayClass) throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(arrayClass); - arrayLength.invoke(null); + assertThrows(NullPointerException.class, () -> arrayLength.invoke(null)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testArrayLengthNoArray() { - MethodHandles.arrayLength(String.class); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.arrayLength(String.class)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testArrayLengthNPE() { - MethodHandles.arrayLength(null); + assertThrows(NullPointerException.class, () -> MethodHandles.arrayLength(null)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullReference() throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(String[].class); - int len = (int)arrayLength.invokeExact((String[])null); + assertThrows(NullPointerException.class, () -> { + int len = (int)arrayLength.invokeExact((String[])null); + }); } } diff --git a/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java b/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java index 369c2c2bea1..a2756fc2f23 100644 --- a/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java +++ b/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -22,20 +22,19 @@ */ /* @test - * @run testng/othervm CallerSensitiveMethodHandle + * @run junit/othervm CallerSensitiveMethodHandle * @summary Check Lookup findVirtual, findStatic and unreflect behavior with * caller sensitive methods with focus on AccessibleObject.setAccessible */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Field; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class CallerSensitiveMethodHandle { private static int field = 0; @@ -46,7 +45,7 @@ public class CallerSensitiveMethodHandle { MethodHandle mh = l.findVirtual(Field.class, "setInt", methodType(void.class, Object.class, int.class)); int newValue = 5; mh.invokeExact(f, (Object) null, newValue); - assertTrue(field == newValue); + assertEquals(newValue, field); } @Test @@ -55,6 +54,6 @@ public class CallerSensitiveMethodHandle { MethodHandle MH_lookup2 = lookup.findStatic(MethodHandles.class, "lookup", methodType(Lookup.class)); Lookup lookup2 = (Lookup) MH_lookup2.invokeExact(); System.out.println(lookup2 + " original lookup class " + lookup.lookupClass()); - assertTrue(lookup2.lookupClass() == lookup.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.lookupClass()); } } diff --git a/test/jdk/java/lang/invoke/ClassSpecializerTest.java b/test/jdk/java/lang/invoke/ClassSpecializerTest.java index 671cf39e217..8bc5c58ad52 100644 --- a/test/jdk/java/lang/invoke/ClassSpecializerTest.java +++ b/test/jdk/java/lang/invoke/ClassSpecializerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -24,15 +24,13 @@ /* @test * @summary Smoke-test class specializer, used to create BoundMethodHandle classes * @compile/module=java.base java/lang/invoke/ClassSpecializerHelper.java - * @run testng/othervm/timeout=250 -ea -esa ClassSpecializerTest + * @run junit/othervm/timeout=250 -ea -esa ClassSpecializerTest */ // Useful diagnostics to try: // -Djava.lang.invoke.MethodHandle.TRACE_RESOLVE=true // -Djava.lang.invoke.MethodHandle.DUMP_CLASS_FILES=true - -import org.testng.annotations.*; import java.lang.invoke.*; import java.util.ArrayList; import java.util.Arrays; @@ -40,6 +38,11 @@ import java.util.List; import static java.lang.invoke.ClassSpecializerHelper.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + public class ClassSpecializerTest { @Test @@ -58,12 +61,12 @@ public class ClassSpecializerTest { } args.set(0, key * 1000 + 42); Frob f = (Frob) mh.invokeWithArguments(args.toArray()); - assert(f.kind() == k); + assertSame(k, f.kind()); System.out.println("k.f(...) = " + f.toString()); List l = f.asList(); System.out.println("f.l = " + l); args.subList(0,1).clear(); // drop label - assert(args.equals(l)); + assertEquals(args, l); } } private static Object coughUpA(Class pt) throws Throwable { diff --git a/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java b/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java index 848264b83a3..c6e093bd09a 100644 --- a/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java +++ b/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -26,27 +26,19 @@ * @bug 8143232 * @summary Test verifies that LF bootstraps properly when run with COMPILE_THRESHOLD set * @compile CompileThresholdBootstrapTest.java - * @run testng/othervm -Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=30 test.java.lang.invoke.CompileThresholdBootstrapTest + * @run junit/othervm -Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=30 test.java.lang.invoke.CompileThresholdBootstrapTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandles; -import org.testng.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public final class CompileThresholdBootstrapTest { @Test public void testBootstrap() throws Throwable { - Assert.assertEquals((int)MethodHandles.constant(int.class, (int)0).invokeExact(), 0); - } - - public static void main(String ... args) { - try { - CompileThresholdBootstrapTest test = new CompileThresholdBootstrapTest(); - test.testBootstrap(); - } catch (Throwable t) { - t.printStackTrace(); - } + assertEquals(0, (int)MethodHandles.constant(int.class, (int)0).invokeExact()); } } diff --git a/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java b/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java index 320fd29abe6..43770ea023b 100644 --- a/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java +++ b/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -23,7 +23,7 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng/othervm -ea -esa test.java.lang.invoke.ConstantIdentityMHTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ConstantIdentityMHTest */ package test.java.lang.invoke; @@ -31,13 +31,14 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ConstantIdentityMHTest { - @DataProvider(name = "testZeroData") - private Object[][] testZeroData() { + private static Object[][] testZeroData() { return new Object[][] { {void.class, "()void"}, {int.class, "()int"}, @@ -52,26 +53,27 @@ public class ConstantIdentityMHTest { }; } - @Test(dataProvider = "testZeroData") + @ParameterizedTest + @MethodSource("testZeroData") public void testZero(Class expectedtype, String expected) throws Throwable { - assertEquals(MethodHandles.zero(expectedtype).type().toString(), expected); + assertEquals(expected, MethodHandles.zero(expectedtype).type().toString()); } - @Test(expectedExceptions={ NullPointerException.class }) + @Test public void testZeroNPE() { - MethodHandle mh = MethodHandles.zero(null); + assertThrows(NullPointerException.class, () -> MethodHandles.zero(null)); } @Test void testEmpty() throws Throwable { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); - assertEquals((String)cat.invoke("x","y"), "xy"); + assertEquals("xy", (String)cat.invoke("x","y")); MethodHandle mhEmpty = MethodHandles.empty(cat.type()); - assertEquals((String)mhEmpty.invoke("x","y"), null); + assertNull((String) mhEmpty.invoke("x", "y")); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test void testEmptyNPE() { - MethodHandle lenEmptyMH = MethodHandles.empty(null); + assertThrows(NullPointerException.class, () -> MethodHandles.empty(null)); } } diff --git a/test/jdk/java/lang/invoke/DefineClassTest.java b/test/jdk/java/lang/invoke/DefineClassTest.java index f712c945e59..889607f38f5 100644 --- a/test/jdk/java/lang/invoke/DefineClassTest.java +++ b/test/jdk/java/lang/invoke/DefineClassTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, 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 @@ -23,7 +23,7 @@ /* @test * @modules java.base/java.lang:open - * @run testng/othervm test.DefineClassTest + * @run junit/othervm test.DefineClassTest * @summary Basic test for java.lang.invoke.MethodHandles.Lookup.defineClass */ @@ -38,7 +38,6 @@ import java.net.URLClassLoader; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; @@ -48,7 +47,8 @@ import static java.lang.constant.ConstantDescs.INIT_NAME; import static java.lang.constant.ConstantDescs.MTD_void; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class DefineClassTest { private static final String THIS_PACKAGE = DefineClassTest.class.getPackageName(); @@ -60,9 +60,9 @@ public class DefineClassTest { * protection domain, as a lookup class. */ void testSameAbode(Class clazz, Class lc) { - assertTrue(clazz.getClassLoader() == lc.getClassLoader()); - assertEquals(clazz.getPackageName(), lc.getPackageName()); - assertTrue(clazz.getProtectionDomain() == lc.getProtectionDomain()); + assertSame(lc.getClassLoader(), clazz.getClassLoader()); + assertEquals(lc.getPackageName(), clazz.getPackageName()); + assertSame(lc.getProtectionDomain(), clazz.getProtectionDomain()); } /** @@ -72,8 +72,8 @@ public class DefineClassTest { void testDiscoverable(Class clazz, Lookup lookup) throws Exception { String cn = clazz.getName(); ClassLoader loader = clazz.getClassLoader(); - assertTrue(Class.forName(cn, false, loader) == clazz); - assertTrue(lookup.findClass(cn) == clazz); + assertSame(clazz, Class.forName(cn, false, loader)); + assertSame(clazz, lookup.findClass(cn)); } /** @@ -86,7 +86,7 @@ public class DefineClassTest { Class clazz = lookup.defineClass(generateClass(CLASS_NAME)); // test name - assertEquals(clazz.getName(), CLASS_NAME); + assertEquals(CLASS_NAME, clazz.getName()); // test loader/package/protection-domain testSameAbode(clazz, lookup.lookupClass()); @@ -95,10 +95,8 @@ public class DefineClassTest { testDiscoverable(clazz, lookup); // attempt defineClass again - try { - lookup.defineClass(generateClass(CLASS_NAME)); - assertTrue(false); - } catch (LinkageError expected) { } + var bytes = generateClass(CLASS_NAME); + assertThrows(LinkageError.class, () -> lookup.defineClass(bytes)); } /** @@ -126,10 +124,7 @@ public class DefineClassTest { classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method4"); Class clazz = lookup.defineClass(classBytes); Runnable r = (Runnable) clazz.newInstance(); - try { - r.run(); - assertTrue(false); - } catch (IllegalAccessError expected) { } + assertThrows(IllegalAccessError.class, r::run); } public static void method1() { } @@ -154,12 +149,8 @@ public class DefineClassTest { Class clazz = lookup().defineClass(classBytes); // trigger initializer to run - try { - clazz.newInstance(); - assertTrue(false); - } catch (ExceptionInInitializerError e) { - assertTrue(e.getCause() instanceof IllegalCallerException); - } + var e = assertThrows(ExceptionInInitializerError.class, clazz::newInstance); + assertInstanceOf(IllegalCallerException.class, e.getCause()); } static void fail() { throw new IllegalCallerException(); } @@ -189,9 +180,9 @@ public class DefineClassTest { ClassLoader loader = new URLClassLoader(new URL[] { url1, url2 }); Class target1 = Class.forName("p.C1", false, loader); Class target2 = Class.forName("p.C2", false, loader); - assertTrue(target1.getClassLoader() == loader); - assertTrue(target1.getClassLoader() == loader); - assertNotEquals(target1.getProtectionDomain(), target2.getProtectionDomain()); + assertSame(loader, target1.getClassLoader()); + assertSame(loader, target1.getClassLoader()); + assertNotEquals(target2.getProtectionDomain(), target1.getProtectionDomain()); // protection domain 1 Lookup lookup1 = privateLookupIn(target1, lookup()); @@ -214,43 +205,43 @@ public class DefineClassTest { @Test public void testBootLoader() throws Exception { Lookup lookup = privateLookupIn(Thread.class, lookup()); - assertTrue(lookup.getClass().getClassLoader() == null); + assertNull(lookup.getClass().getClassLoader()); Class clazz = lookup.defineClass(generateClass("java.lang.Foo")); - assertEquals(clazz.getName(), "java.lang.Foo"); + assertEquals("java.lang.Foo", clazz.getName()); testSameAbode(clazz, Thread.class); testDiscoverable(clazz, lookup); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testWrongPackage() throws Exception { - lookup().defineClass(generateClass("other.C")); + assertThrows(IllegalArgumentException.class, () -> lookup().defineClass(generateClass("other.C"))); } - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testNoPackageAccess() throws Exception { Lookup lookup = lookup().dropLookupMode(PACKAGE); - lookup.defineClass(generateClass(THIS_PACKAGE + ".C")); + assertThrows(IllegalAccessException.class, () -> lookup.defineClass(generateClass(THIS_PACKAGE + ".C"))); } - @Test(expectedExceptions = { ClassFormatError.class }) + @Test public void testTruncatedClassFile() throws Exception { - lookup().defineClass(new byte[0]); + assertThrows(ClassFormatError.class, () -> lookup().defineClass(new byte[0])); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test public void testNull() throws Exception { - lookup().defineClass(null); + assertThrows(NullPointerException.class, () -> lookup().defineClass(null)); } - @Test(expectedExceptions = { NoClassDefFoundError.class }) + @Test public void testLinking() throws Exception { - lookup().defineClass(generateNonLinkableClass(THIS_PACKAGE + ".NonLinkableClass")); + assertThrows(NoClassDefFoundError.class, () -> lookup().defineClass(generateNonLinkableClass(THIS_PACKAGE + ".NonLinkableClass"))); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testModuleInfo() throws Exception { - lookup().defineClass(generateModuleInfo()); + assertThrows(IllegalArgumentException.class, () -> lookup().defineClass(generateModuleInfo())); } /** diff --git a/test/jdk/java/lang/invoke/DropArgumentsTest.java b/test/jdk/java/lang/invoke/DropArgumentsTest.java index 2df9b5f63ba..fb82bb312cd 100644 --- a/test/jdk/java/lang/invoke/DropArgumentsTest.java +++ b/test/jdk/java/lang/invoke/DropArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -24,19 +24,24 @@ /* @test * @bug 8158169 * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng test.java.lang.invoke.DropArgumentsTest + * @run junit test.java.lang.invoke.DropArgumentsTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class DropArgumentsTest { @@ -53,8 +58,7 @@ public class DropArgumentsTest { } - @DataProvider(name = "dropArgumentsToMatchNPEData") - private Object[][] dropArgumentsToMatchNPEData() + private static Object[][] dropArgumentsToMatchNPEData() throws NoSuchMethodException, IllegalAccessException { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); return new Object[][] { @@ -63,13 +67,13 @@ public class DropArgumentsTest { }; } - @Test(dataProvider = "dropArgumentsToMatchNPEData", expectedExceptions = { NullPointerException.class }) + @ParameterizedTest + @MethodSource("dropArgumentsToMatchNPEData") public void dropArgumentsToMatchNPE(MethodHandle target, int pos, List> valueType, int skip) { - MethodHandles.dropArgumentsToMatch(target, pos, valueType , skip); + assertThrows(NullPointerException.class, () -> MethodHandles.dropArgumentsToMatch(target, pos, valueType, skip)); } - @DataProvider(name = "dropArgumentsToMatchIAEData") - private Object[][] dropArgumentsToMatchIAEData() + private static Object[][] dropArgumentsToMatchIAEData() throws NoSuchMethodException, IllegalAccessException { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); MethodType bigType = cat.type().insertParameterTypes(0, String.class, String.class, int.class); @@ -82,17 +86,20 @@ public class DropArgumentsTest { }; } - @Test(dataProvider = "dropArgumentsToMatchIAEData", expectedExceptions = { IllegalArgumentException.class }) + @ParameterizedTest + @MethodSource("dropArgumentsToMatchIAEData") public void dropArgumentsToMatchIAE(MethodHandle target, int pos, List> valueType, int skip) { - MethodHandles.dropArgumentsToMatch(target, pos, valueType , skip); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.dropArgumentsToMatch(target, pos, valueType, skip)); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void dropArgumentsToMatchTestWithVoid() throws Throwable { MethodHandle cat = lookup().findVirtual(String.class, "concat", - MethodType.methodType(String.class, String.class)); - MethodType bigTypewithVoid = cat.type().insertParameterTypes(0, void.class, String.class, int.class); - MethodHandle handle2 = MethodHandles.dropArgumentsToMatch(cat, 0, bigTypewithVoid.parameterList(), 1); + MethodType.methodType(String.class, String.class)); + List> bigTypewithVoid = new ArrayList<>(cat.type().parameterList()); + bigTypewithVoid.addAll(0, List.of(void.class, String.class, int.class)); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.dropArgumentsToMatch(cat, 0, bigTypewithVoid, 1)); } public static class MethodSet { diff --git a/test/jdk/java/lang/invoke/DropLookupModeTest.java b/test/jdk/java/lang/invoke/DropLookupModeTest.java index 1a4c311be8b..7619793c3c6 100644 --- a/test/jdk/java/lang/invoke/DropLookupModeTest.java +++ b/test/jdk/java/lang/invoke/DropLookupModeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -21,9 +21,9 @@ * questions. */ -/** +/* * @test - * @run testng DropLookupModeTest + * @run junit DropLookupModeTest * @summary Basic unit tests Lookup::dropLookupMode */ @@ -31,83 +31,85 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; -@Test public class DropLookupModeTest { /** * Basic test of dropLookupMode */ + @Test public void testBasic() { final Lookup fullPowerLookup = MethodHandles.lookup(); final Class lc = fullPowerLookup.lookupClass(); - assertTrue(fullPowerLookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PROTECTED|PRIVATE|ORIGINAL)); + assertEquals(PUBLIC | MODULE | PACKAGE | PROTECTED | PRIVATE | ORIGINAL, fullPowerLookup.lookupModes()); Lookup lookup = fullPowerLookup.dropLookupMode(PRIVATE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PROTECTED); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PACKAGE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(UNCONDITIONAL); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); } /** * Starting with a full power Lookup, use dropLookupMode to create new Lookups * with reduced access. */ + @Test public void testReducingAccess() { Lookup lookup = MethodHandles.lookup(); final Class lc = lookup.lookupClass(); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PROTECTED|PRIVATE|ORIGINAL)); + assertEquals(PUBLIC | MODULE | PACKAGE | PROTECTED | PRIVATE | ORIGINAL, lookup.lookupModes()); lookup = lookup.dropLookupMode(PROTECTED); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); lookup = lookup.dropLookupMode(PRIVATE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE, lookup.lookupModes()); lookup = lookup.dropLookupMode(PACKAGE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE, lookup.lookupModes()); lookup = lookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == PUBLIC); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC, lookup.lookupModes()); lookup = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); // repeat with lookup has no access lookup = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); } - @DataProvider(name = "unconditionals") - public Object[][] unconditionals() { + public static Object[][] unconditionals() { Lookup publicLookup = MethodHandles.publicLookup(); return new Object[][] { { publicLookup, Object.class }, @@ -120,9 +122,10 @@ public class DropLookupModeTest { * Test dropLookupMode on the lookup with public lookup * and UNCONDITIONAL */ - @Test(dataProvider = "unconditionals") + @ParameterizedTest + @MethodSource("unconditionals") public void testUnconditionalLookup(Lookup unconditionalLookup, Class expected) { - assertTrue(unconditionalLookup.lookupModes() == UNCONDITIONAL); + assertEquals(UNCONDITIONAL, unconditionalLookup.lookupModes()); assertPublicLookup(unconditionalLookup.dropLookupMode(PRIVATE), expected); assertPublicLookup(unconditionalLookup.dropLookupMode(PROTECTED), expected); @@ -132,31 +135,27 @@ public class DropLookupModeTest { // drop all access Lookup lookup = unconditionalLookup.dropLookupMode(UNCONDITIONAL); - assertTrue(lookup.lookupClass() == expected); - assertTrue(lookup.lookupModes() == 0); + assertSame(expected, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); } private void assertPublicLookup(Lookup lookup, Class expected) { - assertTrue(lookup.lookupClass() == expected); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); - } - - @DataProvider(name = "badInput") - public Object[][] badInput() { - return new Object[][] { - { 0, null }, - { (PACKAGE|PRIVATE), null }, // two modes - { Integer.MAX_VALUE, null }, - { Integer.MIN_VALUE, null }, - }; + assertSame(expected, lookup.lookupClass()); + assertEquals(UNCONDITIONAL, lookup.lookupModes()); } /** * Check that IllegalArgumentException is thrown for bad input */ - @Test(dataProvider = "badInput", expectedExceptions = {IllegalArgumentException.class}) - public void testBadInput(Integer modeToDrop, Object ignore) { - MethodHandles.lookup().dropLookupMode(modeToDrop); + @ParameterizedTest + @ValueSource(ints = { + 0, + (PACKAGE|PRIVATE), // two modes + Integer.MAX_VALUE, + Integer.MIN_VALUE, + }) + public void testBadInput(int modeToDrop) { + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().dropLookupMode(modeToDrop)); } } diff --git a/test/jdk/java/lang/invoke/FilterArgumentsTest.java b/test/jdk/java/lang/invoke/FilterArgumentsTest.java index 3c4884e7c6a..2326799cc1c 100644 --- a/test/jdk/java/lang/invoke/FilterArgumentsTest.java +++ b/test/jdk/java/lang/invoke/FilterArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, 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 @@ -24,7 +24,7 @@ /* * @test * @bug 8194554 - * @run testng/othervm test.java.lang.invoke.FilterArgumentsTest + * @run junit/othervm test.java.lang.invoke.FilterArgumentsTest */ package test.java.lang.invoke; @@ -37,40 +37,40 @@ import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.methodType; -import org.testng.annotations.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class FilterArgumentsTest { @Test - public static void testFilterA_B_C() throws Throwable { + public void testFilterA_B_C() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 0, MH_FILTER_A, MH_FILTER_B, MH_FILTER_C)); test.run(List.of("A", "B", "C")); } @Test - public static void testFilterA_B() throws Throwable { + public void testFilterA_B() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 0, MH_FILTER_A, MH_FILTER_B)); test.run(List.of("A", "B")); } @Test - public static void testFilterB_C() throws Throwable { + public void testFilterB_C() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 1, MH_FILTER_B, MH_FILTER_C)); test.run(List.of("B", "C")); } @Test - public static void testFilterB() throws Throwable { + public void testFilterB() throws Throwable { FilterTest test = new FilterTest(filterArguments(MH_TEST, 1, MH_FILTER_B)); test.run(List.of("B")); } @Test - public static void testFilterC() throws Throwable { + public void testFilterC() throws Throwable { FilterTest test = new FilterTest(filterArguments(MH_TEST, 2, MH_FILTER_C)); test.run(List.of("C")); } @@ -85,8 +85,8 @@ public class FilterArgumentsTest { void run(List expected) throws Throwable { filters.clear(); - assertEquals((String)mh.invokeExact("x", 0, 'z'), "x-0-z"); - assertEquals(filters, expected); + assertEquals("x-0-z", (String)mh.invokeExact("x", 0, 'z')); + assertEquals(expected, filters); } static String filterA(String s) { diff --git a/test/jdk/java/lang/invoke/FindAccessTest.java b/test/jdk/java/lang/invoke/FindAccessTest.java index f8602ee22bd..3bcff4f5324 100644 --- a/test/jdk/java/lang/invoke/FindAccessTest.java +++ b/test/jdk/java/lang/invoke/FindAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -23,7 +23,7 @@ /* @test * @bug 8139885 - * @run testng/othervm -ea -esa test.java.lang.invoke.FindAccessTest + * @run junit/othervm -ea -esa test.java.lang.invoke.FindAccessTest */ package test.java.lang.invoke; @@ -33,9 +33,10 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; /** * Tests for Lookup.findClass/accessClass extensions added in JEP 274. @@ -45,7 +46,7 @@ public class FindAccessTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFindSpecial() throws Throwable { + public void testFindSpecial() throws Throwable { FindSpecial.C c = new FindSpecial.C(); assertEquals("I1.m", c.m()); MethodType t = MethodType.methodType(String.class); @@ -54,25 +55,18 @@ public class FindAccessTest { } @Test - public static void testFindSpecialAbstract() throws Throwable { + public void testFindSpecialAbstract() throws Throwable { FindSpecial.C c = new FindSpecial.C(); assertEquals("q", c.q()); MethodType t = MethodType.methodType(String.class); - boolean caught = false; - try { - MethodHandle ci3q = LOOKUP.findSpecial(FindSpecial.I3.class, "q", t, FindSpecial.C.class); - } catch (Throwable thrown) { - if (!(thrown instanceof IllegalAccessException) || !FindSpecial.ABSTRACT_ERROR.equals(thrown.getMessage())) { - throw new AssertionError(thrown.getMessage(), thrown); - } - caught = true; - } - assertTrue(caught); + var thrown = assertThrows(IllegalAccessException.class, + () -> LOOKUP.findSpecial(FindSpecial.I3.class, "q", t, FindSpecial.C.class)); + assertEquals(FindSpecial.ABSTRACT_ERROR, thrown.getMessage()); } - @Test(expectedExceptions = {ClassNotFoundException.class}) - public static void testFindClassCNFE() throws ClassNotFoundException, IllegalAccessException { - LOOKUP.findClass("does.not.Exist"); + @Test + public void testFindClassCNFE() throws ClassNotFoundException, IllegalAccessException { + assertThrows(ClassNotFoundException.class, () -> LOOKUP.findClass("does.not.Exist")); } static class FindSpecial { diff --git a/test/jdk/java/lang/invoke/FoldTest.java b/test/jdk/java/lang/invoke/FoldTest.java index 157cfbffe2e..92ba246ebc8 100644 --- a/test/jdk/java/lang/invoke/FoldTest.java +++ b/test/jdk/java/lang/invoke/FoldTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -23,7 +23,7 @@ /* @test * @bug 8139885 - * @run testng/othervm -ea -esa test.java.lang.invoke.FoldTest + * @run junit/othervm -ea -esa test.java.lang.invoke.FoldTest */ package test.java.lang.invoke; @@ -36,9 +36,9 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; /** * Tests for the new fold method handle combinator added in JEP 274. @@ -48,7 +48,7 @@ public class FoldTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFold0a() throws Throwable { + public void testFold0a() throws Throwable { // equivalence to foldArguments(MethodHandle,MethodHandle) MethodHandle fold = MethodHandles.foldArguments(Fold.MH_multer, 0, Fold.MH_adder); assertEquals(Fold.MT_folded1, fold.type()); @@ -56,7 +56,7 @@ public class FoldTest { } @Test - public static void testFold1a() throws Throwable { + public void testFold1a() throws Throwable { // test foldArguments for folding position 1 MethodHandle fold = MethodHandles.foldArguments(Fold.MH_multer, 1, Fold.MH_adder1); assertEquals(Fold.MT_folded1, fold.type()); @@ -64,7 +64,7 @@ public class FoldTest { } @Test - public static void testFold0b() throws Throwable { + public void testFold0b() throws Throwable { // test foldArguments equivalence with multiple types MethodHandle fold = MethodHandles.foldArguments(Fold.MH_str, 0, Fold.MH_comb); assertEquals(Fold.MT_folded2, fold.type()); @@ -72,7 +72,7 @@ public class FoldTest { } @Test - public static void testFold1b() throws Throwable { + public void testFold1b() throws Throwable { // test folgArguments for folding position 1, with multiple types MethodHandle fold = MethodHandles.foldArguments(Fold.MH_str, 1, Fold.MH_comb2); assertEquals(Fold.MT_folded3, fold.type()); @@ -81,7 +81,7 @@ public class FoldTest { } @Test - public static void testFoldArgumentsExample() throws Throwable { + public void testFoldArgumentsExample() throws Throwable { // test the JavaDoc foldArguments-with-pos example StringWriter swr = new StringWriter(); MethodHandle trace = LOOKUP.findVirtual(StringWriter.class, "write", methodType(void.class, String.class)).bindTo(swr); diff --git a/test/jdk/java/lang/invoke/InvokeGenericTest.java b/test/jdk/java/lang/invoke/InvokeGenericTest.java index ef201caead1..0be810506de 100644 --- a/test/jdk/java/lang/invoke/InvokeGenericTest.java +++ b/test/jdk/java/lang/invoke/InvokeGenericTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandle.invoke * @compile InvokeGenericTest.java - * @run testng/othervm test.java.lang.invoke.InvokeGenericTest + * @run junit/othervm test.java.lang.invoke.InvokeGenericTest */ package test.java.lang.invoke; @@ -34,9 +34,13 @@ import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; import java.lang.reflect.*; import java.util.*; -import org.testng.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; /** * @@ -68,7 +72,7 @@ public class InvokeGenericTest { String testName; static int allPosTests, allNegTests; int posTests, negTests; - @AfterMethod + @AfterEach public void printCounts() { if (verbosity >= 2 && (posTests | negTests) != 0) { System.out.println(); @@ -92,14 +96,14 @@ public class InvokeGenericTest { testName = name; } - @BeforeClass + @BeforeAll public static void setUpClass() throws Exception { calledLog.clear(); calledLog.add(null); nextArgVal = INITIAL_ARG_VAL; } - @AfterClass + @AfterAll public static void tearDownClass() throws Exception { int posTests = allPosTests, negTests = allNegTests; if (verbosity >= 2 && (posTests | negTests) != 0) { @@ -127,7 +131,7 @@ public class InvokeGenericTest { System.out.println("actual: "+actual); System.out.println("ex. types: "+getClasses(expected)); System.out.println("act. types: "+getClasses(actual)); - assertEquals("previous method call", expected, actual); + assertEquals(expected, actual, "previous method call"); } static void printCalled(MethodHandle target, String name, Object... args) { if (verbosity >= 3) @@ -389,8 +393,7 @@ public class InvokeGenericTest { } public void testWrongArgumentCount(List> expect, List> observe) throws Throwable { countTest(false); - if (expect.equals(observe)) - assert(false); + assertNotEquals(expect, observe); MethodHandle target = callable(expect); Object[] args = zeroArgs(observe); Object junk; @@ -473,28 +476,25 @@ public class InvokeGenericTest { mh = MethodHandles.filterReturnValue(mh, toString_MH); mh = mh.asType(type); Object res = null; - if (nargs == 2) { - res = mh.invoke((Object)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = mh.invoke((Object)args[0], (String)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (String)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (CharSequence)args[1]); - assertEquals(expectString, res); - res = mh.invoke((CharSequence)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (String) mh.invoke((Object)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (String) mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (CharSequence) mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - } else { - assert(false); // write this code - } + assertEquals(2, nargs); + res = mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((Object)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (CharSequence)args[1]); + assertEquals(expectString, res); + res = mh.invoke((CharSequence)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (CharSequence) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); //System.out.println(res); } diff --git a/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java b/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java index 2479c22b2f4..f2749cfb164 100644 --- a/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java +++ b/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -25,7 +25,7 @@ * @test * @bug 8157246 * @summary Tests invocation of MethodHandle with invalid leading argument - * @run testng/othervm test.java.lang.invoke.InvokeMethodHandleWithBadArgument + * @run junit/othervm test.java.lang.invoke.InvokeMethodHandleWithBadArgument */ package test.java.lang.invoke; @@ -38,9 +38,9 @@ import java.lang.invoke.VarHandle; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests invocation of MethodHandle with invalid leading argument such as @@ -49,86 +49,100 @@ import org.testng.annotations.*; public class InvokeMethodHandleWithBadArgument { // ---- null array reference ---- - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderPosInvokeWithNull() throws Throwable { + @Test + public void testAsSpreaderPosInvokeWithNull() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 3); - spreader.invoke("A", null, "B"); + assertThrows(NullPointerException.class, () -> spreader.invoke("A", null, "B")); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderInvokeWithNull() throws Throwable { + @Test + public void testAsSpreaderInvokeWithNull() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 2); - assert ((boolean) spreader.invokeExact(new String[]{"me", "me"})); - boolean eq = (boolean) spreader.invokeExact((String[]) null); + assertTrue((boolean) spreader.invokeExact(new String[]{"me", "me"})); + assertThrows(NullPointerException.class, () -> { + boolean eq = (boolean) spreader.invokeExact((String[]) null); + }); } // ---- incorrect array element count ---- - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderPosInvokeWithBadElementCount() throws Throwable { + @Test + public void testAsSpreaderPosInvokeWithBadElementCount() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 3); - spreader.invoke("A", new int[]{1, 2}, "B"); + assertThrows(IllegalArgumentException.class, () -> spreader.invoke("A", new int[]{1, 2}, "B")); } - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderInvokeWithBadElementCount() throws Throwable { + @Test + public void testAsSpreaderInvokeWithBadElementCount() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 2); - assert (!(boolean) spreader.invokeExact(new String[]{"me", "thee"})); - boolean eq = (boolean) spreader.invokeExact(new String[0]); + assertFalse((boolean) spreader.invokeExact(new String[]{"me", "thee"})); + assertThrows(IllegalArgumentException.class, () -> { + boolean eq = (boolean) spreader.invokeExact(new String[0]); + }); } // ---- spread no argument ---- @Test - public static void testAsSpreaderPosInvokeWithZeroLength() throws Throwable { + public void testAsSpreaderPosInvokeWithZeroLength() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 0); - assert("A123B".equals(spreader.invoke("A", (int[])null, 1, 2, 3, "B"))); + assertEquals("A123B", spreader.invoke("A", (int[]) null, 1, 2, 3, "B")); } @Test - public static void testAsSpreaderInvokeWithZeroLength() throws Throwable { + public void testAsSpreaderInvokeWithZeroLength() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 0); - assert ((boolean) spreader.invokeExact("me", (Object)"me", new String[0])); + assertTrue((boolean) spreader.invokeExact("me", (Object)"me", new String[0])); boolean eq = (boolean) spreader.invokeExact("me", (Object)"me", (String[]) null); } // ---- invokers with null method/var handle argument ---- - @Test(expectedExceptions = {NullPointerException.class}) - public static void testInvokerWithNull() throws Throwable { + @Test + public void testInvokerWithNull() throws Throwable { MethodType type = methodType(int.class, int.class, int.class); MethodHandle invoker = MethodHandles.invoker(type); - assert((int) invoker.invoke(MH_add, 1, 2) == 3); - int sum = (int)invoker.invoke((MethodHandle)null, 1, 2); + assertEquals(3, (int) invoker.invoke(MH_add, 1, 2)); + assertThrows(NullPointerException.class, () -> { + int sum = (int)invoker.invoke((MethodHandle)null, 1, 2); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testExactInvokerWithNull() throws Throwable { + @Test + public void testExactInvokerWithNull() throws Throwable { MethodType type = methodType(int.class, int.class, int.class); MethodHandle invoker = MethodHandles.exactInvoker(type); - assert((int) invoker.invoke(MH_add, 1, 2) == 3); - int sum = (int)invoker.invokeExact((MethodHandle)null, 1, 2); + assertEquals(3, (int) invoker.invoke(MH_add, 1, 2)); + assertThrows(NullPointerException.class, () -> { + int sum = (int)invoker.invokeExact((MethodHandle)null, 1, 2); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testSpreadInvokerWithNull() throws Throwable { + @Test + public void testSpreadInvokerWithNull() throws Throwable { MethodType type = methodType(boolean.class, String.class, String.class); MethodHandle invoker = MethodHandles.spreadInvoker(type, 0); - assert ((boolean) invoker.invoke(MH_String_equals, new String[]{"me", "me"})); - boolean eq = (boolean) invoker.invoke((MethodHandle)null, new String[]{"me", "me"}); + assertTrue((boolean) invoker.invoke(MH_String_equals, new String[]{"me", "me"})); + assertThrows(NullPointerException.class, () -> { + boolean eq = (boolean) invoker.invoke((MethodHandle)null, new String[]{"me", "me"}); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testVarHandleInvokerWithNull() throws Throwable { + @Test + public void testVarHandleInvokerWithNull() throws Throwable { VarHandle.AccessMode am = VarHandle.AccessMode.GET; MethodHandle invoker = MethodHandles.varHandleInvoker(am, VH_array.accessModeType(am)); - assert ((int) invoker.invoke(VH_array, array, 3) == 3); - int value = (int)invoker.invoke((VarHandle)null, array, 3); + assertEquals(3, (int) invoker.invoke(VH_array, array, 3)); + assertThrows(NullPointerException.class, () -> { + int value = (int)invoker.invoke((VarHandle)null, array, 3); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testVarHandleExactInvokerWithNull() throws Throwable { + @Test + public void testVarHandleExactInvokerWithNull() throws Throwable { VarHandle.AccessMode am = VarHandle.AccessMode.GET; MethodHandle invoker = MethodHandles.varHandleExactInvoker(am, VH_array.accessModeType(am)); - assert ((int) invoker.invoke(VH_array, array, 3) == 3); - int value = (int)invoker.invokeExact((VarHandle)null, array, 3); + assertEquals(3, (int) invoker.invoke(VH_array, array, 3)); + assertThrows(NullPointerException.class, () -> { + int value = (int)invoker.invokeExact((VarHandle)null, array, 3); + }); } static final Lookup LOOKUP = MethodHandles.lookup(); diff --git a/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java b/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java index 63a2101bd67..3a705aca699 100644 --- a/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java +++ b/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -23,19 +23,19 @@ /* @test * @summary basic tests for MethodHandle.invokeWithArguments - * @run testng test.java.lang.invoke.InvokeWithArgumentsTest + * @run junit test.java.lang.invoke.InvokeWithArgumentsTest */ package test.java.lang.invoke; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.WrongMethodTypeException; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class InvokeWithArgumentsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -49,10 +49,7 @@ public class InvokeWithArgumentsTest { MethodHandle mh = L.findStatic(L.lookupClass(), "arity", methodType(Object[].class, Object.class, Object.class, Object[].class)); - try { - mh.invokeWithArguments(""); - Assert.fail("WrongMethodTypeException expected"); - } catch (WrongMethodTypeException e) {} + assertThrows(WrongMethodTypeException.class, () -> mh.invokeWithArguments("")); } static Object[] passThrough(String... a) { @@ -72,10 +69,10 @@ public class InvokeWithArgumentsTest { // Note: the actual array is not preserved, the elements will be // unpacked and then packed into a new array before invoking the method - String[] expected = (String[]) mh.invokeWithArguments(actual); + String[] result = (String[]) mh.invokeWithArguments(actual); - Assert.assertTrue(actual != expected, "Array should not pass through"); - Assert.assertEquals(actual, expected, "Array contents should be equal"); + assertNotSame(actual, result, "Array should not pass through"); + assertArrayEquals(actual, result, "Array contents should be equal"); } @Test @@ -89,8 +86,8 @@ public class InvokeWithArgumentsTest { // will cast to Object become the single element of a new Object[] array Object[] expected = (Object[]) mh.invokeWithArguments("", actual); - Assert.assertEquals(1, expected.length, "Array should contain just one element"); - Assert.assertTrue(actual == expected[0], "Array should pass through"); + assertEquals(1, expected.length, "Array should contain just one element"); + assertSame(actual, expected[0], "Array should pass through"); } static void intArray(int... a) { @@ -100,20 +97,14 @@ public class InvokeWithArgumentsTest { public void testPrimitiveArrayWithNull() throws Throwable { MethodHandle mh = L.findStatic(L.lookupClass(), "intArray", methodType(void.class, int[].class)); - try { - mh.invokeWithArguments(null, null); - Assert.fail("NullPointerException expected"); - } catch (NullPointerException e) {} + assertThrows(NullPointerException.class, () -> mh.invokeWithArguments(null, null)); } @Test public void testPrimitiveArrayWithRef() throws Throwable { MethodHandle mh = L.findStatic(L.lookupClass(), "intArray", methodType(void.class, int[].class)); - try { - mh.invokeWithArguments("A", "B"); - Assert.fail("ClassCastException expected"); - } catch (ClassCastException e) {} + assertThrows(ClassCastException.class, () -> mh.invokeWithArguments("A", "B")); } @@ -127,9 +118,6 @@ public class InvokeWithArgumentsTest { // All numbers, should not throw mh.invokeWithArguments(1, 1.0, 1.0F, 1L); - try { - mh.invokeWithArguments("A"); - Assert.fail("ClassCastException expected"); - } catch (ClassCastException e) {} + assertThrows(ClassCastException.class, () -> mh.invokeWithArguments("A")); } } diff --git a/test/jdk/java/lang/invoke/JavaDocExamplesTest.java b/test/jdk/java/lang/invoke/JavaDocExamplesTest.java index 53257d9876d..0fa2614c83f 100644 --- a/test/jdk/java/lang/invoke/JavaDocExamplesTest.java +++ b/test/jdk/java/lang/invoke/JavaDocExamplesTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2025, 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 @@ -24,7 +24,7 @@ /* @test * @summary example code used in javadoc for java.lang.invoke API * @compile JavaDocExamplesTest.java - * @run testng/othervm test.java.lang.invoke.JavaDocExamplesTest + * @run junit/othervm test.java.lang.invoke.JavaDocExamplesTest */ package test.java.lang.invoke; @@ -36,8 +36,8 @@ import static java.lang.invoke.MethodType.*; import java.util.*; -import org.testng.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; /** * @author jrose @@ -350,14 +350,14 @@ assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum")); static void assertEquals(Object exp, Object act) { if (verbosity > 0) System.out.println("result: "+act); - Assert.assertEquals(exp, act); + Assertions.assertEquals(exp, act); } static void assertTrue(boolean b) { if (verbosity > 0) { System.out.println("result: " + b); } - Assert.assertTrue(b); + Assertions.assertTrue(b); } @Test public void testMethodHandlesSummary() throws Throwable { diff --git a/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java b/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java index 9715de8fd46..a9a6861bc05 100644 --- a/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java +++ b/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, 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 @@ -25,12 +25,11 @@ * @summary Tests that Lookup can be produced from classes under java.util.concurrent * @bug 8154447 * @compile/module=java.base java/util/concurrent/LookupTester.java - * @run testng/othervm JavaUtilConcurrentLookupTest + * @run junit/othervm JavaUtilConcurrentLookupTest */ -import org.testng.annotations.Test; - import java.util.concurrent.LookupTester; +import org.junit.jupiter.api.Test; public class JavaUtilConcurrentLookupTest { diff --git a/test/jdk/java/lang/invoke/LoopCombinatorTest.java b/test/jdk/java/lang/invoke/LoopCombinatorTest.java index 15fb9d320a3..91a752f2666 100644 --- a/test/jdk/java/lang/invoke/LoopCombinatorTest.java +++ b/test/jdk/java/lang/invoke/LoopCombinatorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -32,7 +32,7 @@ * @bug 8154751 * @bug 8154754 * @bug 8167974 - * @run testng/othervm -ea -esa test.java.lang.invoke.LoopCombinatorTest + * @run junit/othervm -ea -esa test.java.lang.invoke.LoopCombinatorTest */ package test.java.lang.invoke; @@ -45,9 +45,12 @@ import java.util.*; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests for the loop combinators introduced in JEP 274. @@ -57,7 +60,7 @@ public class LoopCombinatorTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testLoopFac() throws Throwable { + public void testLoopFac() throws Throwable { MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause); @@ -66,7 +69,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopFacNullInit() throws Throwable { + public void testLoopFacNullInit() throws Throwable { // null initializer for counter, should initialize to 0 MethodHandle[] counterClause = new MethodHandle[]{null, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -76,7 +79,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopNullInit() throws Throwable { + public void testLoopNullInit() throws Throwable { // null initializer for counter, should initialize to 0, one-clause loop MethodHandle[] counterClause = new MethodHandle[]{null, Loop.MH_inc, Loop.MH_pred, Loop.MH_fin}; MethodHandle loop = MethodHandles.loop(counterClause); @@ -85,7 +88,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid1() throws Throwable { + public void testLoopVoid1() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state MethodHandle loop = MethodHandles.loop(new MethodHandle[]{Empty.MH_f, Empty.MH_f, Empty.MH_pred, null}); assertEquals(MethodType.methodType(void.class), loop.type()); @@ -93,7 +96,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid2() throws Throwable { + public void testLoopVoid2() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // initialized implicitly from the step type MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, null}); @@ -102,7 +105,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid3() throws Throwable { + public void testLoopVoid3() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // and that has a void finalizer MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_f}); @@ -111,7 +114,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopFacWithVoidState() throws Throwable { + public void testLoopFacWithVoidState() throws Throwable { // like testLoopFac, but with additional void state that outputs a dot MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -122,7 +125,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoidInt() throws Throwable { + public void testLoopVoidInt() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // and that returns a constant MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_c}); @@ -131,7 +134,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopWithVirtuals() throws Throwable { + public void testLoopWithVirtuals() throws Throwable { // construct a loop (to calculate factorial) that uses a mix of static and virtual methods MethodHandle[] counterClause = new MethodHandle[]{null, LoopWithVirtuals.permute(LoopWithVirtuals.MH_inc)}; MethodHandle[] accumulatorClause = new MethodHandle[]{ @@ -147,7 +150,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopOmitPred() throws Throwable { + public void testLoopOmitPred() throws Throwable { // construct a loop to calculate factorial that omits a predicate MethodHandle[] counterClause = new MethodHandle[]{null, Fac.MH_inc, null, Fac.MH_fin}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -156,7 +159,6 @@ public class LoopCombinatorTest { assertEquals(120, loop.invoke(5)); } - @DataProvider static Object[][] negativeTestData() { MethodHandle i0 = MethodHandles.constant(int.class, 0); MethodHandle ii = MethodHandles.dropArguments(i0, 0, int.class, int.class); @@ -214,36 +216,36 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "negativeTestData") - public static void testLoopNegative(MethodHandle[][] clauses, String expectedMessage) throws Throwable { - boolean caught = false; - try { - MH_loop.invokeWithArguments((Object[]) clauses); - } catch (IllegalArgumentException iae) { - assertEquals(expectedMessage, iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("negativeTestData") + public void testLoopNegative(MethodHandle[][] clauses, String expectedMessage) throws Throwable { + var iae = assertThrows(IllegalArgumentException.class, () -> MH_loop.invokeWithArguments((Object[]) clauses)); + assertEquals(expectedMessage, iae.getMessage()); } - @Test(dataProvider = "whileLoopTestData") - public static void testWhileLoop(MethodHandle MH_zero, - MethodHandle MH_pred, - MethodHandle MH_step, - String messageOrNull) throws Throwable { + @ParameterizedTest + @MethodSource("whileLoopPassData") + public void testWhileLoop(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step) throws Throwable { // int i = 0; while (i < limit) { ++i; } return i; => limit - try { - MethodHandle loop = MethodHandles.whileLoop(MH_zero, MH_pred, MH_step); - assert messageOrNull == null; - if (MH_step.type().equals(While.MH_step.type())) - assertEquals(While.MT_while, loop.type()); - assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); - while (loop.type().parameterCount() > 1) loop = snip(loop); - assertEquals(23, loop.invoke(23)); - } catch (IllegalArgumentException iae) { - assert messageOrNull != null; - assertEqualsFIXME(messageOrNull, iae.getMessage()); - } + MethodHandle loop = MethodHandles.whileLoop(MH_zero, MH_pred, MH_step); + if (MH_step.type().equals(While.MH_step.type())) + assertEquals(While.MT_while, loop.type()); + assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); + while (loop.type().parameterCount() > 1) loop = snip(loop); + assertEquals(23, loop.invoke(23)); + } + + @ParameterizedTest + @MethodSource("whileLoopFailData") + public void testWhileLoopFail(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step, + String message) throws Throwable { + // int i = 0; while (i < limit) { ++i; } return i; => limit + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.whileLoop(MH_zero, MH_pred, MH_step)); + assertEqualsFIXME(message, iae.getMessage()); } static void assertEqualsFIXME(String expect, String actual) { @@ -253,8 +255,7 @@ public class LoopCombinatorTest { } } - @DataProvider - static Object[][] whileLoopTestData() { + static Object[][] whileLoopPassData() { MethodHandle zeroI = While.MH_zero, zeroX = snip(zeroI), @@ -268,28 +269,44 @@ public class LoopCombinatorTest { ; return new Object[][] { // normal while loop clauses, perhaps with effectively-identical reductions - {zeroI, predII, stepII, null}, - {zeroX, predII, stepII, null}, - {null, predII, stepII, null}, + {zeroI, predII, stepII}, + {zeroX, predII, stepII}, + {null, predII, stepII}, // expanded while loop clauses - {zeroIB, predIIB, stepIIB, null}, - {zeroI, predIIB, stepIIB, null}, - {null, predIIB, stepIIB, null}, - {zeroIB, predII, stepIIB, null}, - {zeroX, predII, stepIIB, null}, - {null, predII, stepIIB, null}, - // short step clauses cause errors - {zeroI, predII, stepIX, "loop predicate must match: (int,int)boolean != (int)boolean"}, - {zeroIB, predIX, stepIX, "loop initializer must match: (int,byte)int != ()int"}, - // bad body type - {zeroI, predII, tweak(stepII, -1, char.class), "body function must match: (int,int)char != (char,int,int)char"}, - {zeroI, predII, tweak(stepII, 0, char.class), "body function must match: (char,int)int != (int,char,int)int"}, - // bad pred type - {zeroI, tweak(predII, -1, char.class), stepII, "loop predicate must match: (int,int)char != (int,int)boolean"}, - {zeroI, tweak(predII, 0, char.class), stepII, "loop predicate must match: (char,int)boolean != (int,int)boolean"}, - // bad init type - {tweak(zeroI, -1, char.class), predII, stepII, "loop initializer must match: (int)char != (int)int"}, - {tweak(zeroI, 0, char.class), predII, stepII, "loop initializer must match: (char)int != (int)int"}, + {zeroIB, predIIB, stepIIB}, + {zeroI, predIIB, stepIIB}, + {null, predIIB, stepIIB}, + {zeroIB, predII, stepIIB}, + {zeroX, predII, stepIIB}, + {null, predII, stepIIB}, + }; + } + + static Object[][] whileLoopFailData() { + MethodHandle + zeroI = While.MH_zero, + zeroX = snip(zeroI), + zeroIB = slap(zeroI, byte.class), + predII = While.MH_pred, + predIX = snip(predII), + predIIB = slap(predII, byte.class), + stepII = While.MH_step, + stepIX = snip(stepII), + stepIIB = slap(stepII, byte.class) + ; + return new Object[][] { + // short step clauses cause errors + {zeroI, predII, stepIX, "loop predicate must match: (int,int)boolean != (int)boolean"}, + {zeroIB, predIX, stepIX, "loop initializer must match: (int,byte)int != ()int"}, + // bad body type + {zeroI, predII, tweak(stepII, -1, char.class), "body function must match: (int,int)char != (char,int,int)char"}, + {zeroI, predII, tweak(stepII, 0, char.class), "body function must match: (char,int)int != (int,char,int)int"}, + // bad pred type + {zeroI, tweak(predII, -1, char.class), stepII, "loop predicate must match: (int,int)char != (int,int)boolean"}, + {zeroI, tweak(predII, 0, char.class), stepII, "loop predicate must match: (char,int)boolean != (int,int)boolean"}, + // bad init type + {tweak(zeroI, -1, char.class), predII, stepII, "loop initializer must match: (int)char != (int)int"}, + {tweak(zeroI, 0, char.class), predII, stepII, "loop initializer must match: (char)int != (int)int"}, }; } @@ -323,53 +340,50 @@ public class LoopCombinatorTest { } @Test - public static void testWhileLoopNoIteration() throws Throwable { + public void testWhileLoopNoIteration() throws Throwable { // a while loop that never executes its body because the predicate evaluates to false immediately MethodHandle loop = MethodHandles.whileLoop(While.MH_initString, While.MH_predString, While.MH_stepString); assertEquals(While.MT_string, loop.type()); assertEquals("a", loop.invoke()); } - @Test(dataProvider = "whileLoopTestData") - public static void testDoWhileLoop(MethodHandle MH_zero, - MethodHandle MH_pred, - MethodHandle MH_step, - String messageOrNull) throws Throwable { + @ParameterizedTest + @MethodSource("whileLoopPassData") + public void testDoWhileLoopPass(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step) throws Throwable { // int i = 0; do { ++i; } while (i < limit); return i; => limit - try { - MethodHandle loop = MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred); - assert messageOrNull == null; - if (MH_step.type().equals(While.MH_step.type())) - assertEquals(While.MT_while, loop.type()); - assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); - while (loop.type().parameterCount() > 1) loop = snip(loop); - assertEquals(23, loop.invoke(23)); - } catch (IllegalArgumentException iae) { - assert messageOrNull != null; - if (!messageOrNull.equals(iae.getMessage())) { - // just issue a warning - System.out.println("*** "+messageOrNull+"\n != "+iae.getMessage()); - } - } + MethodHandle loop = MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred); + if (MH_step.type().equals(While.MH_step.type())) + assertEquals(While.MT_while, loop.type()); + assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); + while (loop.type().parameterCount() > 1) loop = snip(loop); + assertEquals(23, loop.invoke(23)); + } + + @ParameterizedTest + @MethodSource("whileLoopFailData") + public void testDoWhileLoopFail(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step, + String message) throws Throwable { + // int i = 0; do { ++i; } while (i < limit); return i; => limit + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred)); + assertEqualsFIXME(message, iae.getMessage()); } @Test - public static void testDoWhileBadInit() throws Throwable { - boolean caught = false; - try { - While w = new While(); - MethodHandle loop = MethodHandles.doWhileLoop(MethodHandles.empty(methodType(char.class)), - While.MH_voidBody.bindTo(w), - While.MH_voidPred.bindTo(w)); - } catch (IllegalArgumentException iae) { - assertEquals("loop initializer must match: ()char != (int)void", iae.getMessage()); - caught = true; - } - assertTrue(caught); + public void testDoWhileBadInit() throws Throwable { + While w = new While(); + var iae = assertThrows(IllegalArgumentException.class, () -> + MethodHandles.doWhileLoop(MethodHandles.empty(methodType(char.class)), + While.MH_voidBody.bindTo(w), + While.MH_voidPred.bindTo(w))); + assertEquals("loop initializer must match: ()char != (int)void", iae.getMessage()); } @Test - public static void testWhileZip() throws Throwable { + public void testWhileZip() throws Throwable { MethodHandle loop = MethodHandles.doWhileLoop(While.MH_zipInitZip, While.MH_zipStep, While.MH_zipPred); assertEquals(While.MT_zip, loop.type()); List a = Arrays.asList("a", "b", "c", "d"); @@ -379,22 +393,17 @@ public class LoopCombinatorTest { } @Test - public static void testWhileBadInit() throws Throwable { - boolean caught = false; - try { - While w = new While(); - MethodHandle loop = MethodHandles.whileLoop(MethodHandles.empty(methodType(void.class, char.class)), - While.MH_voidPred.bindTo(w), - While.MH_voidBody.bindTo(w)); - } catch (IllegalArgumentException iae) { - assertEquals("loop initializer must match: (char)void != (int)void", iae.getMessage()); - caught = true; - } - assertTrue(caught); + public void testWhileBadInit() throws Throwable { + While w = new While(); + var iae = assertThrows(IllegalArgumentException.class, () -> + MethodHandles.whileLoop(MethodHandles.empty(methodType(void.class, char.class)), + While.MH_voidPred.bindTo(w), + While.MH_voidBody.bindTo(w))); + assertEquals("loop initializer must match: (char)void != (int)void", iae.getMessage()); } @Test - public static void testWhileVoidInit() throws Throwable { + public void testWhileVoidInit() throws Throwable { While w = new While(); int v = 5; MethodHandle loop = MethodHandles.whileLoop(While.MH_voidInit.bindTo(w), While.MH_voidPred.bindTo(w), @@ -405,7 +414,7 @@ public class LoopCombinatorTest { } @Test - public static void testDoWhileVoidInit() throws Throwable { + public void testDoWhileVoidInit() throws Throwable { While w = new While(); int v = 5; MethodHandle loop = MethodHandles.doWhileLoop(While.MH_voidInit.bindTo(w), While.MH_voidBody.bindTo(w), @@ -415,24 +424,25 @@ public class LoopCombinatorTest { assertEquals(v, w.i); } - @DataProvider static Object[][] nullArgs() { MethodHandle c = MethodHandles.constant(int.class, 1); return new Object[][]{{null, c}, {c, null}}; } - @Test(dataProvider = "nullArgs", expectedExceptions = NullPointerException.class) - public static void testWhileNullArgs(MethodHandle pred, MethodHandle body) { - MethodHandles.whileLoop(null, pred, body); + @ParameterizedTest + @MethodSource("nullArgs") + public void testWhileNullArgs(MethodHandle pred, MethodHandle body) { + assertThrows(NullPointerException.class, () -> MethodHandles.whileLoop(null, pred, body)); } - @Test(dataProvider = "nullArgs", expectedExceptions = NullPointerException.class) - public static void testDoWhileNullArgs(MethodHandle body, MethodHandle pred) { - MethodHandles.whileLoop(null, body, pred); + @ParameterizedTest + @MethodSource("nullArgs") + public void testDoWhileNullArgs(MethodHandle body, MethodHandle pred) { + assertThrows(NullPointerException.class, () -> MethodHandles.whileLoop(null, body, pred)); } @Test - public static void testCountedLoop() throws Throwable { + public void testCountedLoop() throws Throwable { // String s = "Lambdaman!"; for (int i = 0; i < 13; ++i) { s = "na " + s; } return s; => a variation on a well known theme MethodHandle fit13 = MethodHandles.dropArguments(MethodHandles.constant(int.class, 13), 0, String.class); MethodHandle loop = MethodHandles.countedLoop(fit13, Counted.MH_start, Counted.MH_step); @@ -441,7 +451,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopVoidInit() throws Throwable { + public void testCountedLoopVoidInit() throws Throwable { MethodHandle fit5 = MethodHandles.constant(int.class, 5); for (int i = 0; i < 8; i++) { MethodHandle zero = MethodHandles.zero(void.class); @@ -465,7 +475,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedArrayLoop() throws Throwable { + public void testCountedArrayLoop() throws Throwable { // int[] a = new int[]{0}; for (int i = 0; i < 13; ++i) { ++a[0]; } => a[0] == 13 MethodHandle fit13 = MethodHandles.dropArguments(MethodHandles.constant(int.class, 13), 0, int[].class); MethodHandle loop = MethodHandles.countedLoop(fit13, null, Counted.MH_stepUpdateArray); @@ -476,37 +486,30 @@ public class LoopCombinatorTest { } @Test - public static void testCountedPrintingLoop() throws Throwable { + public void testCountedPrintingLoop() throws Throwable { MethodHandle fit5 = MethodHandles.constant(int.class, 5); MethodHandle loop = MethodHandles.countedLoop(fit5, null, Counted.MH_printHello); assertEquals(Counted.MT_countedPrinting, loop.type()); loop.invoke(); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullBody() throws Throwable { + @Test + public void testCountedLoopNullBody() throws Throwable { MethodHandle h5 = MethodHandles.constant(int.class, 5); MethodHandle h13 = MethodHandles.constant(int.class, 13); - MethodHandle loop = MethodHandles.countedLoop(h5, h13, null); - assertEquals(methodType(int.class), loop.type()); - assertEquals(13, loop.invoke()); + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(h5, h13, null)); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullIterations() throws Throwable { - MethodHandle loop = MethodHandles.countedLoop(null, null, null); - assertEquals(methodType(void.class), loop.type()); - loop.invoke(); + @Test + public void testCountedLoopNullIterations() throws Throwable { + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(null, null, null)); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullInitAndBody() throws Throwable { - MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, null); - assertEquals(methodType(void.class), loop.type()); - loop.invoke(); + @Test + public void testCountedLoopNullInitAndBody() throws Throwable { + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, null)); } - @DataProvider static Object[][] countedLoopBodyParameters() { Class V = String.class, I = int.class, A = List.class; // return types are of these forms: @@ -531,8 +534,9 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "countedLoopBodyParameters") - public static void testCountedLoopBodyParameters(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { + @ParameterizedTest + @MethodSource("countedLoopBodyParameters") + public void testCountedLoopBodyParameters(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { MethodHandle loop = MethodHandles.countedLoop( MethodHandles.empty(countType), initType == null ? null : MethodHandles.empty(initType), @@ -546,13 +550,14 @@ public class LoopCombinatorTest { assertEquals(expectType, loop.type()); } - @Test(dataProvider = "countedLoopBodyParameters") - public static void testCountedLoopBodyParametersNullInit(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { + @ParameterizedTest + @MethodSource("countedLoopBodyParameters") + public void testCountedLoopBodyParametersNullInit(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { testCountedLoopBodyParameters(countType, null, bodyType); } @Test - public static void testCountedLoopStateInitializedToNull() throws Throwable { + public void testCountedLoopStateInitializedToNull() throws Throwable { MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), MethodHandles.empty(methodType(String.class)), Counted.MH_stateBody); assertEquals(Counted.MT_bodyDeterminesState, loop.type()); @@ -560,7 +565,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopArgsDefinedByIterations() throws Throwable { + public void testCountedLoopArgsDefinedByIterations() throws Throwable { MethodHandle iterations = MethodHandles.dropArguments(MethodHandles.constant(int.class, 3), 0, String.class); MethodHandle loop = MethodHandles.countedLoop(iterations, @@ -570,7 +575,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedRangeLoop() throws Throwable { + public void testCountedRangeLoop() throws Throwable { // String s = "Lambdaman!"; for (int i = -5; i < 8; ++i) { s = "na " + s; } return s; => a well known theme MethodHandle fitm5 = MethodHandles.dropArguments(Counted.MH_m5, 0, String.class); MethodHandle fit8 = MethodHandles.dropArguments(Counted.MH_8, 0, String.class); @@ -580,7 +585,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopCounterInit() throws Throwable { + public void testCountedLoopCounterInit() throws Throwable { // int x = 0; for (int i = 0; i < 5; ++i) { x += i; } return x; => 10 // (only if counter's first value in body is 0) MethodHandle iter = MethodHandles.constant(int.class, 5); @@ -592,7 +597,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopEmpty() throws Throwable { + public void testCountedLoopEmpty() throws Throwable { // for (int i = 0; i < 5; ++i) { /* empty */ } MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, MethodHandles.empty(methodType(void.class, int.class))); @@ -601,7 +606,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedRangeLoopEmpty() throws Throwable { + public void testCountedRangeLoopEmpty() throws Throwable { // for (int i = -5; i < 5; ++i) { /* empty */ } MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, -5), MethodHandles.constant(int.class, 5), null, MethodHandles.empty(methodType(void.class, int.class))); @@ -609,7 +614,6 @@ public class LoopCombinatorTest { loop.invoke(); } - @DataProvider static Object[][] countedLoopNegativeData() { MethodHandle dummy = MethodHandles.zero(void.class); MethodHandle one = MethodHandles.constant(int.class, 1); @@ -629,35 +633,30 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "countedLoopNegativeData") - public static void testCountedLoopNegative(MethodHandle start, MethodHandle end, MethodHandle init, + @ParameterizedTest + @MethodSource("countedLoopNegativeData") + @Disabled //%%%FIXME%%%% + public void testCountedLoopNegative(MethodHandle start, MethodHandle end, MethodHandle init, MethodHandle body, String msg) { - if (true) return; //%%%FIXME%%%% - boolean caught = false; - try { - MethodHandles.countedLoop(start, end, init, body); - } catch (IllegalArgumentException iae) { - assertEquals(msg, iae.getMessage()); - caught = true; - } - assertTrue(caught); + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.countedLoop(start, end, init, body)); + assertEquals(msg, iae.getMessage()); } @Test - public static void testIterateSum() throws Throwable { + public void testIterateSum() throws Throwable { // Integer[] a = new Integer[]{1,2,3,4,5,6}; int sum = 0; for (int e : a) { sum += e; } return sum; => 21 MethodHandle loop = MethodHandles.iteratedLoop(Iterate.MH_sumIterator, Iterate.MH_sumInit, Iterate.MH_sumStep); assertEquals(Iterate.MT_sum, loop.type()); assertEquals(21, loop.invoke(new Integer[]{1, 2, 3, 4, 5, 6})); } - @DataProvider static Object[][] iteratorInits() { return new Object[][]{{Iterate.MH_iteratorFromList}, {Iterate.MH_iteratorFromIterable}, {null}}; } - @Test(dataProvider = "iteratorInits") - public static void testIterateReverse(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateReverse(MethodHandle iterator) throws Throwable { // this test uses List as its loop state type; don't try to change that if (iterator != null) iterator = iterator.asType(iterator.type().changeParameterType(0, List.class)); @@ -685,8 +684,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIterateLength(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateLength(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_lengthStep; MethodHandle init = Iterate.MH_lengthInit; MethodType expectedType = Iterate.MT_length; @@ -708,8 +708,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIterateMap(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateMap(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_mapStep; MethodHandle init = Iterate.MH_mapInit; MethodType expectedType = Iterate.MT_map; @@ -731,8 +732,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIteratePrint(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIteratePrint(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_printStep; MethodType expectedType = Iterate.MT_print; int barity = body.type().parameterCount(); @@ -747,32 +749,28 @@ public class LoopCombinatorTest { loop.invoke(Arrays.asList("hello", "world")); } - @Test(expectedExceptions = NullPointerException.class) - public static void testIterateNullBody() { - MethodHandles.iteratedLoop(MethodHandles.empty(methodType(Iterator.class, int.class)), - MethodHandles.identity(int.class), null); + @Test + public void testIterateNullBody() { + assertThrows(NullPointerException.class, () -> + MethodHandles.iteratedLoop(MethodHandles.empty(methodType(Iterator.class, int.class)), + MethodHandles.identity(int.class), null)); } - @DataProvider static Object[][] wrongIteratorTypes() { return new Object[][]{{void.class}, {Object.class}, {Iterable.class}}; } - @Test(dataProvider = "wrongIteratorTypes") - public static void testIterateVoidIterator(Class it) { - boolean caught = false; + @ParameterizedTest + @MethodSource("wrongIteratorTypes") + public void testIterateVoidIterator(Class it) { MethodType v = methodType(it); - try { - MethodHandles.iteratedLoop(MethodHandles.empty(v), null, MethodHandles.empty(v)); - } catch(IllegalArgumentException iae) { - assertEqualsFIXME("iteratedLoop first argument must have Iterator return type", iae.getMessage()); - caught = true; - } - assertTrue(caught); + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.iteratedLoop(MethodHandles.empty(v), null, MethodHandles.empty(v))); + assertEqualsFIXME("iteratedLoop first argument must have Iterator return type", iae.getMessage()); } - @Test(dataProvider = "iteratorInits") - public static void testIterateVoidInit(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateVoidInit(MethodHandle iterator) throws Throwable { // this test uses List as its loop state type; don't try to change that if (iterator != null) iterator = iterator.asType(iterator.type().changeParameterType(0, List.class)); @@ -781,7 +779,6 @@ public class LoopCombinatorTest { loop.invoke(Arrays.asList("hello", "world")); } - @DataProvider static Object[][] iterateParameters() { MethodType i = methodType(int.class); MethodType sil_v = methodType(void.class, String.class, int.class, List.class); @@ -811,8 +808,9 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "iterateParameters") - public static void testIterateParameters(MethodType it, MethodType in, MethodType bo, String msg) { + @ParameterizedTest + @MethodSource("iterateParameters") + public void testIterateParameters(MethodType it, MethodType in, MethodType bo, String msg) { boolean negative = !msg.isEmpty(); MethodHandle iterator = it == null ? null : MethodHandles.empty(it); MethodHandle init = in == null ? null : MethodHandles.empty(in); @@ -855,7 +853,7 @@ public class LoopCombinatorTest { } @Test - public static void testIteratorSubclass() throws Throwable { + public void testIteratorSubclass() throws Throwable { MethodHandle loop = MethodHandles.iteratedLoop(MethodHandles.empty(methodType(BogusIterator.class, List.class)), null, MethodHandles.empty(methodType(void.class, String.class, List.class))); assertEquals(methodType(void.class, List.class), loop.type()); diff --git a/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java b/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java index e728516fe03..510a65acabf 100644 --- a/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java +++ b/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -24,20 +24,18 @@ /* @test * @summary Test MethodHandle::invokeExact and MethodHandle::invoke throws * UnsupportedOperationException when called via Method::invoke - * @run testng test.java.lang.invoke.MethodHandleInvokeUOE + * @run junit test.java.lang.invoke.MethodHandleInvokeUOE */ package test.java.lang.invoke; -import org.testng.*; -import org.testng.annotations.*; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.Test; public class MethodHandleInvokeUOE { @Test diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java b/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java index 0e9c708e8e9..2d99db46c2c 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java @@ -25,8 +25,8 @@ * @test * @bug 8280377 * @build m1/* m2/* Unnamed - * @run testng/othervm m1/p1.Main - * @run main/othervm Unnamed + * @run junit/othervm m1/p1.Main + * @run junit/othervm Unnamed * @summary Test MethodHandleProxies::asInterfaceInstance with a default * method with varargs */ diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java b/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java index f60f36ca9de..8cd9a37cc2f 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java @@ -26,13 +26,16 @@ import java.lang.invoke.MethodHandleProxies; import java.lang.invoke.MethodHandles; import java.lang.reflect.Method; -import static org.testng.Assert.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; /* * Test MethodHandleProxies::asInterfaceInstance with an inaccessible interface */ public class Unnamed { - public static void main(String... args) throws Throwable { + @Test + void testInaccessible() throws Throwable { MethodHandle target = MethodHandles.constant(String.class, "test"); Class intf = Class.forName("p2.TestIntf"); Object t = MethodHandleProxies.asInterfaceInstance(intf, target); diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java index 1bdeddce28f..5e0174635fb 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2025, 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 @@ -22,6 +22,6 @@ */ module m1 { requires m2; - requires org.testng; + requires org.junit.platform.console.standalone; exports p1; } diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java index df71809996b..1e4ffcb4aac 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2025, 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 @@ -32,9 +32,8 @@ import java.util.stream.Collectors; import p2.TestIntf; -import org.testng.annotations.Test; - -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class Main { public interface A { @@ -57,24 +56,24 @@ public class Main { * Test the invocation of default methods with varargs */ @Test - public static void testVarargsMethods() throws Throwable { + public void testVarargsMethods() throws Throwable { MethodHandle target = MethodHandles.lookup().findStatic(Main.class, "concat", MethodType.methodType(String.class, Object[].class)); C proxy = MethodHandleProxies.asInterfaceInstance(C.class, target); - assertEquals(proxy.c("a", "b", "c"), "abc"); - assertEquals(proxy.aConcat("a", "b", "c"), "[a, b, c]"); - assertEquals(proxy.aConcat(new Object[] { "a", "b", "c" }), "[a, b, c]"); - assertEquals(proxy.bConcat(new Object[] { "a", "b", "c" }), "[a, b, c]"); + assertEquals("abc", proxy.c("a", "b", "c")); + assertEquals("[a, b, c]", proxy.aConcat("a", "b", "c")); + assertEquals("[a, b, c]", proxy.aConcat(new Object[] { "a", "b", "c" })); + assertEquals("[a, b, c]", proxy.bConcat(new Object[] { "a", "b", "c" })); } /* * Test the invocation of a default method of an accessible interface */ @Test - public static void modulePrivateInterface() { + public void modulePrivateInterface() { MethodHandle target = MethodHandles.constant(String.class, "test"); TestIntf t = MethodHandleProxies.asInterfaceInstance(TestIntf.class, target); - assertEquals(t.test(), "test"); + assertEquals("test", t.test()); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java b/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java index ff31dd63f0b..1b8ef6331b3 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java +++ b/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -24,33 +24,33 @@ /* * @test * @bug 8255398 - * @run testng TestDropReturn + * @run junit TestDropReturn */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestDropReturn { - @Test(dataProvider = "dropReturnCases") + @ParameterizedTest + @MethodSource("dropReturnCases") public void testDropReturn(Class cls, Object testValue) throws Throwable { MethodHandle mh = MethodHandles.identity(cls); - assertEquals(mh.type(), methodType(cls, cls)); + assertEquals(methodType(cls, cls), mh.type()); Object x = mh.invoke(testValue); - assertEquals(x, testValue); + assertEquals(testValue, x); mh = MethodHandles.dropReturn(mh); - assertEquals(mh.type(), methodType(void.class, cls)); + assertEquals(methodType(void.class, cls), mh.type()); mh.invoke(testValue); // should at least work } - @DataProvider public static Object[][] dropReturnCases() { return new Object[][]{ { boolean.class, true }, diff --git a/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java b/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java index 4ff1a99cc28..960d98fb387 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java +++ b/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -23,13 +23,9 @@ /* * @test - * @run testng/othervm -Xverify:all TestTableSwitch + * @run junit/othervm -Xverify:all TestTableSwitch */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - -import javax.management.ObjectName; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; @@ -38,7 +34,11 @@ import java.util.List; import java.util.function.IntConsumer; import java.util.function.IntFunction; -import static org.testng.Assert.assertEquals; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; public class TestTableSwitch { @@ -111,7 +111,6 @@ public class TestTableSwitch { return args; } - @DataProvider public static Object[][] nonVoidCases() { List tests = new ArrayList<>(); @@ -126,10 +125,11 @@ public class TestTableSwitch { } private static void check(List testValues, Object[] collectedValues) { - assertEquals(collectedValues, testValues.toArray()); + assertArrayEquals(testValues.toArray(), collectedValues); } - @Test(dataProvider = "nonVoidCases") + @ParameterizedTest + @MethodSource("nonVoidCases") public void testNonVoidHandles(Class type, int numCases, List> additionalTypes) throws Throwable { MethodHandle collector = MH_check; List testArguments = new ArrayList<>(); @@ -158,19 +158,19 @@ public class TestTableSwitch { testArguments.add(testValue(additionalType)); } - assertEquals(mhSwitch.invokeWithArguments(testArguments(-1, testArguments)), defaultReturnValue); + assertEquals(defaultReturnValue, mhSwitch.invokeWithArguments(testArguments(-1, testArguments))); for (int i = 0; i < numCases; i++) { - assertEquals(mhSwitch.invokeWithArguments(testArguments(i, testArguments)), returnValues[i]); + assertEquals(returnValues[i], mhSwitch.invokeWithArguments(testArguments(i, testArguments))); } - assertEquals(mhSwitch.invokeWithArguments(testArguments(numCases, testArguments)), defaultReturnValue); + assertEquals(defaultReturnValue, mhSwitch.invokeWithArguments(testArguments(numCases, testArguments))); } @Test public void testVoidHandles() throws Throwable { IntFunction makeTestCase = expectedIndex -> { - IntConsumer test = actualIndex -> assertEquals(actualIndex, expectedIndex); + IntConsumer test = actualIndex -> assertEquals(expectedIndex, actualIndex); return MH_IntConsumer_accept.bindTo(test); }; @@ -187,48 +187,48 @@ public class TestTableSwitch { mhSwitch.invokeExact((int) 2); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullDefaultHandle() { - MethodHandles.tableSwitch(null, simpleTestCase("test")); + assertThrows(NullPointerException.class, () -> MethodHandles.tableSwitch(null, simpleTestCase("test"))); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullCases() { MethodHandle[] cases = null; - MethodHandles.tableSwitch(simpleTestCase("default"), cases); + assertThrows(NullPointerException.class, () -> + MethodHandles.tableSwitch(simpleTestCase("default"), cases)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullCase() { - MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), null); + assertThrows(NullPointerException.class, () -> MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), null)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Not enough cases.*") + @Test public void testNotEnoughCases() { - MethodHandles.tableSwitch(simpleTestCase("default")); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.tableSwitch(simpleTestCase("default"))); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have int as leading parameter.*") + @Test public void testNotEnoughParameters() { MethodHandle empty = MethodHandles.empty(MethodType.methodType(void.class)); - MethodHandles.tableSwitch(empty, empty, empty); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(empty, empty, empty)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have int as leading parameter.*") + @Test public void testNoLeadingIntParameter() { MethodHandle empty = MethodHandles.empty(MethodType.methodType(void.class, double.class)); - MethodHandles.tableSwitch(empty, empty, empty); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(empty, empty, empty)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have the same type.*") + @Test public void testWrongCaseType() { // doesn't return a String MethodHandle wrongType = MethodHandles.empty(MethodType.methodType(void.class, int.class)); - MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), wrongType); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), wrongType)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java b/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java index 5880761f925..f96a6f23162 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java +++ b/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -25,7 +25,7 @@ * @test * @bug 8230501 * @library /test/lib - * @run testng/othervm ClassDataTest + * @run junit/othervm ClassDataTest */ import java.io.IOException; @@ -54,13 +54,14 @@ import java.util.Map; import java.util.function.Consumer; import java.util.stream.Stream; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.*; import static java.lang.constant.ConstantDescs.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ClassDataTest { private static final Lookup LOOKUP = MethodHandles.lookup(); @@ -72,10 +73,10 @@ public class ClassDataTest { assertTrue(lookup.hasFullPrivilegeAccess()); int value = MethodHandles.classData(lookup, "_", int.class); - assertEquals(value, 20); + assertEquals(20, value); Integer i = MethodHandles.classData(lookup, "_", Integer.class); - assertEquals(i.intValue(), 20); + assertEquals(20, i.intValue()); } /* @@ -86,8 +87,7 @@ public class ClassDataTest { assertNull(MethodHandles.classData(LOOKUP, "_", Object.class)); } - @DataProvider(name = "teleportedLookup") - private Object[][] teleportedLookup() throws ReflectiveOperationException { + private static Object[][] teleportedLookup() throws ReflectiveOperationException { Lookup lookup = hiddenClass(30); Class hc = lookup.lookupClass(); assertClassData(lookup, 30); @@ -100,32 +100,33 @@ public class ClassDataTest { }; } - @Test(dataProvider = "teleportedLookup", expectedExceptions = { IllegalAccessException.class }) + @ParameterizedTest + @MethodSource("teleportedLookup") public void illegalAccess(Lookup lookup, int access) throws IllegalAccessException { int lookupModes = lookup.lookupModes(); - assertTrue((lookupModes & ORIGINAL) == 0); - assertEquals(lookupModes, access); - MethodHandles.classData(lookup, "_", int.class); + assertEquals(0, lookupModes & ORIGINAL); + assertEquals(access, lookupModes); + assertThrows(IllegalAccessException.class, () -> MethodHandles.classData(lookup, "_", int.class)); } - @Test(expectedExceptions = { ClassCastException.class }) + @Test public void incorrectType() throws IllegalAccessException { Lookup lookup = hiddenClass(20); - MethodHandles.classData(lookup, "_", Long.class); + assertThrows(ClassCastException.class, () -> MethodHandles.classData(lookup, "_", Long.class)); } - @Test(expectedExceptions = { IndexOutOfBoundsException.class }) + @Test public void invalidIndex() throws IllegalAccessException { Lookup lookup = hiddenClass(List.of()); - MethodHandles.classDataAt(lookup, "_", Object.class, 0); + assertThrows(IndexOutOfBoundsException.class, () -> MethodHandles.classDataAt(lookup, "_", Object.class, 0)); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test public void unboxNull() throws IllegalAccessException { List list = new ArrayList<>(); list.add(null); Lookup lookup = hiddenClass(list); - MethodHandles.classDataAt(lookup, "_", int.class, 0); + assertThrows(NullPointerException.class, () -> MethodHandles.classDataAt(lookup, "_", int.class, 0)); } @Test @@ -133,7 +134,7 @@ public class ClassDataTest { List list = new ArrayList<>(); list.add(null); Lookup lookup = hiddenClass(list); - assertTrue(MethodHandles.classDataAt(lookup, "_", Object.class, 0) == null); + assertNull(MethodHandles.classDataAt(lookup, "_", Object.class, 0)); } @Test @@ -142,7 +143,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, int.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, 100, true); int value = MethodHandles.classData(lookup, "_", int.class); - assertEquals(value, 100); + assertEquals(100, value); // call through condy assertClassData(lookup, 100); } @@ -153,7 +154,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, float.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, 0.1234f, true); float value = MethodHandles.classData(lookup, "_", float.class); - assertEquals(value, 0.1234f); + assertEquals(0.1234f, value); // call through condy assertClassData(lookup, 0.1234f); } @@ -165,7 +166,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, Class.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, hc, true); Class value = MethodHandles.classData(lookup, "_", Class.class); - assertEquals(value, hc); + assertEquals(hc, value); // call through condy assertClassData(lookup, hc); } @@ -181,7 +182,7 @@ public class ClassDataTest { colors[0] = "black"; // it will get back the modified class data String[] value = MethodHandles.classData(lookup, "_", String[].class); - assertEquals(value, colors); + assertArrayEquals(colors, value); // even call through condy as it's not a constant assertClassData(lookup, colors); } @@ -194,7 +195,7 @@ public class ClassDataTest { int expected = 102; // element at index=2 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 2); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy assertClassData(lookup, expected); } @@ -208,7 +209,7 @@ public class ClassDataTest { int expected = 101; // element at index=1 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 1); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy assertClassData(lookup, expected); } @@ -216,20 +217,12 @@ public class ClassDataTest { private static Lookup hiddenClass(int value) { ClassByteBuilder builder = new ClassByteBuilder("HC"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, int.class).build(); - try { - return LOOKUP.defineHiddenClassWithClassData(bytes, value, true); - } catch (Throwable e) { - throw new RuntimeException(e); - } + return assertDoesNotThrow(() -> LOOKUP.defineHiddenClassWithClassData(bytes, value, true)); } private static Lookup hiddenClass(List list) { ClassByteBuilder builder = new ClassByteBuilder("HC"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, List.class).build(); - try { - return LOOKUP.defineHiddenClassWithClassData(bytes, list, true); - } catch (Throwable e) { - throw new RuntimeException(e); - } + return assertDoesNotThrow(() -> LOOKUP.defineHiddenClassWithClassData(bytes, list, true)); } @Test @@ -242,7 +235,7 @@ public class ClassDataTest { Class hc = hcLookup.lookupClass(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, hc, true); Class value = MethodHandles.classData(lookup, "_", Class.class); - assertEquals(value, hc); + assertEquals(hc, value); // call through condy Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance(), hc); @@ -257,7 +250,7 @@ public class ClassDataTest { int expected = 102; // element at index=2 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 2); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance() ,expected); @@ -285,13 +278,13 @@ public class ClassDataTest { Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance(), mtype); // modify the class data - assertTrue(cd.remove(0) == mtype); + assertSame(mtype, cd.remove(0)); cd.add(0, MethodType.methodType(void.class)); MethodType newMType = cd.get(0); // loading the element using condy returns the original value assertClassData(lookup, c.newInstance(), mtype); // direct invocation of MethodHandles.classDataAt returns the modified value - assertEquals(MethodHandles.classDataAt(lookup, "_", MethodType.class, 0), newMType); + assertEquals(newMType, MethodHandles.classDataAt(lookup, "_", MethodType.class, 0)); } // helper method to extract from a class data map @@ -334,7 +327,7 @@ public class ClassDataTest { assertEquals(mh, v1); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void nonDefaultName() throws ReflectiveOperationException { ClassByteBuilder builder = new ClassByteBuilder("nonDefaultName"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, Class.class) @@ -342,7 +335,7 @@ public class ClassDataTest { Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, ClassDataTest.class, true); assertClassData(lookup, ClassDataTest.class); // throw IAE - MethodHandles.classData(lookup, "non_default_name", Class.class); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.classData(lookup, "non_default_name", Class.class)); } static class ClassByteBuilder { @@ -428,7 +421,7 @@ public class ClassDataTest { * Load an int constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, int value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, int value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); int v = (int) m.invoke(null); @@ -439,7 +432,7 @@ public class ClassDataTest { * Load an int constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, int value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, int value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); int v = (int) m.invoke(o); @@ -450,7 +443,7 @@ public class ClassDataTest { * Load a float constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, float value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, float value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); float v = (float) m.invoke(null); @@ -461,7 +454,7 @@ public class ClassDataTest { * Load a Class constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Class value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Class value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Class v = (Class)m.invoke(null); @@ -472,7 +465,7 @@ public class ClassDataTest { * Load a Class from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, Class value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, Class value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(o); @@ -483,18 +476,29 @@ public class ClassDataTest { * Load an Object from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(null); assertEquals(value, v); } + /* + * Load an Object array from class data via condy and + * verify it matches the given value in content. + */ + private static void assertClassData(Lookup lookup, Object[] value) throws ReflectiveOperationException { + Class c = lookup.lookupClass(); + Method m = c.getMethod("classData"); + Object v = m.invoke(null); + assertArrayEquals(value, (Object[]) v); + } + /* * Load an Object from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, Object value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, Object value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(o); diff --git a/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java b/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java index 58146286da1..afb628d31ba 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java +++ b/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -24,16 +24,15 @@ import java.lang.invoke.MethodHandles; import java.lang.reflect.Method; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** * @test * @bug 8235521 * @summary Tests for Lookup::ensureClassInitialized * @build java.base/* m1/* m2/* Main - * @run testng/othervm --add-modules m1 Main + * @run junit/othervm --add-modules m1 Main */ public class Main { @@ -48,20 +47,20 @@ public class Main { } // access denied to package-private java.lang class - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testPackagePrivate() throws Exception { Class c = Class.forName("java.lang.DefaultInit", false, null); assertFalse(Helper.isInitialized(c)); // access denied - MethodHandles.lookup().ensureInitialized(c); + assertThrows(IllegalAccessException.class, () -> MethodHandles.lookup().ensureInitialized(c)); } // access denied to public class in a non-exported package - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testNonExportedPackage() throws Exception { Class c = Class.forName("jdk.internal.misc.VM", false, null); // access denied - MethodHandles.lookup().ensureInitialized(c); + assertThrows(IllegalAccessException.class, () -> MethodHandles.lookup().ensureInitialized(c)); } // invoke p1.Test::test to test module boundary access @@ -72,9 +71,9 @@ public class Main { m.invoke(null); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testArrayType() throws Exception { Class arrayType = PublicInit.class.arrayType(); - MethodHandles.lookup().ensureInitialized(arrayType); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().ensureInitialized(arrayType)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java index 810351bae3e..bf3f1f40913 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, 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 @@ -24,6 +24,6 @@ /** * @test * @build test/* m1/* m2/* m3/* Unnamed - * @run testng/othervm test/p.PrivateLookupInTests + * @run junit/othervm test/p.PrivateLookupInTests * @summary Unit tests for MethodHandles.privateLookupIn */ diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java index da93c879ef1..f364c761aa3 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, 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 @@ -22,6 +22,6 @@ */ module test { - requires org.testng; - exports p to org.testng; // TestNG invokes the public methods + requires org.junit.platform.console.standalone; + exports p to org.junit.platform.console.standalone; // JUnit invokes the public methods in PrivateLookupInTests } diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java index b17204de013..068d2fb534e 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -29,15 +29,14 @@ import java.lang.reflect.Modifier; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /** * Unit tests for MethodHandles.privateLookupIn */ -@Test public class PrivateLookupInTests { /** * A public and non-public types in the test module but in a different @@ -52,24 +51,25 @@ public class PrivateLookupInTests { * private static final Object obj = ... * } */ - private Class publicType; - private Class nonPublicType; + private static Class publicType; + private static Class nonPublicType; // initialize and sanity check publicType/nonPublicType - @BeforeTest - public void init() throws Exception { + @BeforeAll + public static void init() throws Exception { publicType = Class.forName("p.internal.PublicType"); - assertTrue(this.getClass().getModule() == publicType.getModule()); - assertNotEquals(this.getClass().getPackageName(), publicType.getPackageName()); + assertSame(PrivateLookupInTests.class.getModule(), publicType.getModule()); + assertNotEquals(publicType.getPackageName(), PrivateLookupInTests.class.getPackageName()); assertTrue(Modifier.isPublic(publicType.getModifiers())); nonPublicType = Class.forName("p.internal.NonPublicType"); - assertTrue(this.getClass().getModule() == nonPublicType.getModule()); - assertNotEquals(this.getClass().getPackageName(), nonPublicType.getPackageName()); + assertSame(PrivateLookupInTests.class.getModule(), nonPublicType.getModule()); + assertNotEquals(nonPublicType.getPackageName(), PrivateLookupInTests.class.getPackageName()); assertFalse(Modifier.isPublic(nonPublicType.getModifiers())); } // Invoke MethodHandles.privateLookupIn with a full-power caller + @Test public void testAllAccessCallerSameModule() throws Throwable { Lookup lookup = MethodHandles.privateLookupIn(nonPublicType, MethodHandles.lookup()); assertTrue(lookup.lookupClass() == nonPublicType); @@ -82,29 +82,31 @@ public class PrivateLookupInTests { } // Invoke MethodHandles.privateLookupIn with a reduced-power caller - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testReducedAccessCallerSameModule() throws Throwable { Lookup caller = MethodHandles.lookup().dropLookupMode(PACKAGE); - assertTrue((caller.lookupModes() & PRIVATE) == 0); - assertTrue((caller.lookupModes() & PACKAGE) == 0); - assertTrue((caller.lookupModes() & MODULE) != 0); - assertTrue((caller.lookupModes() & ORIGINAL) == 0); - - Lookup lookup = MethodHandles.privateLookupIn(nonPublicType, caller); + assertEquals(0, caller.lookupModes() & PRIVATE); + assertEquals(0, caller.lookupModes() & PACKAGE); + assertNotEquals(0, caller.lookupModes() & MODULE); + assertEquals(0, caller.lookupModes() & ORIGINAL); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(nonPublicType, caller)); } // Invoke MethodHandles.privateLookupIn with the public lookup as caller - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testPublicLookupSameModule() throws Exception { Lookup caller = MethodHandles.publicLookup(); - Lookup lookup = MethodHandles.privateLookupIn(publicType, caller); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(publicType, caller)); } // test reads m1, open module m1 containing p1 + @Test public void testTargetClassInOpenModule() throws Throwable { // m1/p1.Type Class clazz = Class.forName("p1.Type"); - assertEquals(clazz.getModule().getName(), "m1"); + assertEquals("m1", clazz.getModule().getName()); // ensure that this module reads m1 Module thisModule = getClass().getModule(); @@ -113,9 +115,9 @@ public class PrivateLookupInTests { assertTrue(m1.isOpen("p1", thisModule)); Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(lookup.lookupClass() == clazz); - assertTrue((lookup.lookupModes() & PRIVATE) == PRIVATE); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertSame(clazz, lookup.lookupClass()); + assertEquals(PRIVATE, lookup.lookupModes() & PRIVATE); + assertEquals(0, lookup.lookupModes() & MODULE); // get obj field MethodHandle mh = lookup.findStaticGetter(clazz, "obj", Object.class); @@ -123,6 +125,7 @@ public class PrivateLookupInTests { } // test target class in unnamed module + @Test public void testTargetClassInUnnamedModule() throws Throwable { Class clazz = Class.forName("Unnamed"); assertFalse(clazz.getModule().isNamed()); @@ -130,76 +133,72 @@ public class PrivateLookupInTests { // thisModule does not read the unnamed module Module thisModule = getClass().getModule(); assertFalse(thisModule.canRead(clazz.getModule())); - try { - MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(false); - } catch (IllegalAccessException expected) { } + var baseLookup = MethodHandles.lookup(); + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(clazz, baseLookup)); // thisModule reads the unnamed module thisModule.addReads(clazz.getModule()); - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(lookup.lookupClass() == clazz); - assertTrue((lookup.lookupModes() & PRIVATE) == PRIVATE); - assertTrue((lookup.lookupModes() & MODULE) == 0); + Lookup lookup = MethodHandles.privateLookupIn(clazz, baseLookup); + assertSame(clazz, lookup.lookupClass()); + assertEquals(PRIVATE, (lookup.lookupModes() & PRIVATE)); + assertEquals(0, (lookup.lookupModes() & MODULE)); } // test does not read m2, m2 opens p2 to test - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testCallerDoesNotRead() throws Throwable { // m2/p2.Type Class clazz = Class.forName("p2.Type"); - assertEquals(clazz.getModule().getName(), "m2"); - + assertEquals("m2", clazz.getModule().getName()); Module thisModule = getClass().getModule(); Module m2 = clazz.getModule(); assertFalse(thisModule.canRead(m2)); assertTrue(m2.isOpen("p2", thisModule)); - - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(clazz, MethodHandles.lookup())); } // test reads m3, m3 does not open p3 to test - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testNotOpenToCaller() throws Throwable { // m3/p2.Type Class clazz = Class.forName("p3.Type"); - assertEquals(clazz.getModule().getName(), "m3"); - + assertEquals("m3", clazz.getModule().getName()); Module thisModule = getClass().getModule(); Module m3 = clazz.getModule(); thisModule.addReads(clazz.getModule()); assertFalse(m3.isOpen("p3", thisModule)); - - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(clazz, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with a primitive class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testPrimitiveClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(int.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(int.class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with an array class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testArrayClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(PrivateLookupInTests[].class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(PrivateLookupInTests[].class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with a primitive array class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testPrimitiveArrayClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(int[].class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(int[].class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with null - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void testNullTargetClass() throws Exception { - MethodHandles.privateLookupIn(null, MethodHandles.lookup()); + assertThrows(NullPointerException.class, () -> MethodHandles.privateLookupIn(null, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with null - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void testNullCaller() throws Exception { - MethodHandles.privateLookupIn(getClass(), null); + assertThrows(NullPointerException.class, () -> MethodHandles.privateLookupIn(getClass(), null)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java b/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java index 5fc0083d5fb..20f03454d32 100644 --- a/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java +++ b/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -23,18 +23,17 @@ /* @test * @bug 8259922 - * @run testng/othervm MethodHandlesCollectArgsTest + * @run junit/othervm MethodHandlesCollectArgsTest */ -import org.testng.annotations.Test; -import org.testng.annotations.DataProvider; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class MethodHandlesCollectArgsTest { @@ -43,7 +42,6 @@ public class MethodHandlesCollectArgsTest { private static final MethodHandle FILTER_INT = MethodHandles.empty(methodType(int.class, String.class)); private static final MethodHandle FILTER_VOID = MethodHandles.empty(methodType(void.class, String.class)); - @DataProvider(name = "illegalPos") public static Object[][] illegalPos() { return new Object[][] { {TARGET_II_I, 2, FILTER_INT}, @@ -57,7 +55,6 @@ public class MethodHandlesCollectArgsTest { }; } - @DataProvider(name = "validPos") public static Object[][] validPos() { return new Object[][] { {TARGET_II_I, 0, FILTER_INT, methodType(int.class, String.class, int.class)}, @@ -69,14 +66,16 @@ public class MethodHandlesCollectArgsTest { }; } - @Test(dataProvider="illegalPos", expectedExceptions = {IllegalArgumentException.class}) + @ParameterizedTest + @MethodSource("illegalPos") public void illegalPosition(MethodHandle target, int position, MethodHandle filter) { - MethodHandles.collectArguments(target, position, filter); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.collectArguments(target, position, filter)); } - @Test(dataProvider="validPos") + @ParameterizedTest + @MethodSource("validPos") public void legalPosition(MethodHandle target, int position, MethodHandle filter, MethodType expectedType) { MethodHandle result = MethodHandles.collectArguments(target, position, filter); - assertEquals(result.type(), expectedType); + assertEquals(expectedType, result.type()); } } diff --git a/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java b/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java index b60c35fc30b..588227fef15 100644 --- a/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java +++ b/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, 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 @@ -60,6 +60,7 @@ import java.util.Map; import static java.lang.invoke.MethodType.methodType; import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; public class MethodHandlesGeneralTest extends MethodHandlesTest { @@ -398,7 +399,7 @@ public class MethodHandlesGeneralTest extends MethodHandlesTest { Object obj = target.invokeWithArguments(args); if (!(defc == Example.class && params.length < 2)) assertCalled(defc.getSimpleName()+".", args); - assertTrue("instance of "+defc.getName(), defc.isInstance(obj)); + assertInstanceOf(defc, obj); } @Test @@ -971,8 +972,7 @@ public class MethodHandlesGeneralTest extends MethodHandlesTest { arrayToMH = new SubIntExample[length]; else return; // can't make an ArrayStoreException test - assert(arrayType.isInstance(arrayToMH)) - : Arrays.asList(arrayType, arrayToMH.getClass(), testSetter, negTest); + assertInstanceOf(arrayType, arrayToMH, () -> Arrays.asList(testSetter, negTest).toString()); break; } countTest(positive); diff --git a/test/jdk/java/lang/invoke/MethodTypeTest.java b/test/jdk/java/lang/invoke/MethodTypeTest.java index 8ac03d1a7fd..dccc82fa348 100644 --- a/test/jdk/java/lang/invoke/MethodTypeTest.java +++ b/test/jdk/java/lang/invoke/MethodTypeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, 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 @@ -25,7 +25,7 @@ * @bug 8366028 * @summary unit tests for java.lang.invoke.MethodType * @compile MethodTypeTest.java - * @run testng/othervm test.java.lang.invoke.MethodTypeTest + * @run junit/othervm test.java.lang.invoke.MethodTypeTest */ package test.java.lang.invoke; @@ -35,11 +35,13 @@ import java.lang.invoke.MethodType; import java.lang.reflect.Method; import java.util.*; -import org.testng.*; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import static org.testng.Assert.assertThrows; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * @@ -57,7 +59,7 @@ public class MethodTypeTest { private MethodType[] GALLERY; private Method compareTo; - @BeforeMethod + @BeforeEach public void setUp() throws Exception { rtype = void.class; ptypes = new Class[] { int.class, String.class }; @@ -98,7 +100,7 @@ public class MethodTypeTest { }; } - @AfterMethod + @AfterEach public void tearDown() throws Exception { } @@ -107,7 +109,7 @@ public class MethodTypeTest { public void testDistinct() { List gallery2 = new ArrayList<>(); for (MethodType mt : GALLERY) { - assertFalse(mt.toString(), gallery2.contains(mt)); + assertFalse(gallery2.contains(mt), mt.toString()); gallery2.add(mt); } // check self-equality also: @@ -198,9 +200,9 @@ public class MethodTypeTest { for (int i = 0; i < instances.length; i++) { MethodType instance = instances[i]; String result = instance.toMethodDescriptorString(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); MethodType parsed = MethodType.fromMethodDescriptorString(result, loader); - assertSame("--#"+i, instance, parsed); + assertSame(instance, parsed, "--#"+i); } } private static String concat(Object... parts) { @@ -221,8 +223,7 @@ public class MethodTypeTest { return sb.toString().replace('.', '/'); } - @DataProvider(name = "badMethodDescriptorStrings") - public String[] badMethodDescriptorStrings() { + public static String[] badMethodDescriptorStrings() { return new String[] { "(I)", "(V)V", @@ -239,9 +240,12 @@ public class MethodTypeTest { } // JDK-8366028 - @Test(dataProvider = "badMethodDescriptorStrings", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("badMethodDescriptorStrings") public void testFromMethodDescriptorStringNegatives(String desc) { - MethodType.fromMethodDescriptorString(desc, null); + assertThrows(IllegalArgumentException.class, () -> { + MethodType.fromMethodDescriptorString(desc, null); + }); } @Test @@ -251,7 +255,7 @@ public class MethodTypeTest { boolean[] expResults = {true, false, true, false, true, true, false, true}; for (int i = 0; i < instances.length; i++) { boolean result = instances[i].hasPrimitives(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } @@ -263,7 +267,7 @@ public class MethodTypeTest { for (int i = 0; i < instances.length; i++) { System.out.println(" hasWrappers "+instances[i]); boolean result = instances[i].hasWrappers(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } @@ -274,7 +278,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_viO, mt_OO2, mt_vv, mt_Ov, mt_iO2, mt_OOi, mt_OO2, mt_iOi}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].erase(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -285,7 +289,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_OO2, mt_OO2, mt_Ov, mt_Ov, mt_OO2, mt_OO2, mt_OO2, mt_OO2}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].generic(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -296,7 +300,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_VIS, mt_OO2, mt_Vv, mt_Ov, mt_ISI, mt_ISI, mt_ISI, mt_ISI}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].wrap(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -307,7 +311,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_viS, mt_OO2, mt_vv, mt_Ov, mt_iSi, mt_iSi, mt_iSi, mt_iSi}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].unwrap(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -436,7 +440,7 @@ public class MethodTypeTest { MethodType instance = instances[i]; String result = instance.toString(); System.out.println("#"+i+":"+result); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } diff --git a/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java b/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java index b01a4aa2a99..6bd604dcd36 100644 --- a/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java +++ b/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -24,21 +24,21 @@ /* @test * @bug 8184119 * @summary test permutation when return value is directly derived from an argument - * @run testng/othervm test.java.lang.invoke.PermuteArgsReturnVoidTest + * @run junit/othervm test.java.lang.invoke.PermuteArgsReturnVoidTest */ package test.java.lang.invoke; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.dropArguments; import static java.lang.invoke.MethodHandles.identity; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class PermuteArgsReturnVoidTest { @@ -65,8 +65,8 @@ public class PermuteArgsReturnVoidTest { MethodHandle p = MethodHandles.permuteArguments(f, MethodType.methodType(String.class, String.class, int.class, int.class), 0, 2, 1); String s = (String) p.invoke("IN", 0, 0); - Assert.assertEquals(s.getClass(), String.class); - Assert.assertEquals(s, "IN"); + assertEquals(String.class, s.getClass()); + assertEquals("IN", s); } @Test @@ -84,7 +84,7 @@ public class PermuteArgsReturnVoidTest { MethodHandle p = MethodHandles.permuteArguments(f, MethodType.methodType(String.class, String.class, int.class, int.class), 0, 2, 1); String s = (String) p.invoke("IN", 0, 0); - Assert.assertEquals(s.getClass(), String.class); - Assert.assertEquals(s, "IN"); + assertEquals(String.class, s.getClass()); + assertEquals("IN", s); } } diff --git a/test/jdk/java/lang/invoke/PermuteArgsTest.java b/test/jdk/java/lang/invoke/PermuteArgsTest.java index 3586dc9382f..77558714d11 100644 --- a/test/jdk/java/lang/invoke/PermuteArgsTest.java +++ b/test/jdk/java/lang/invoke/PermuteArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @summary unit tests for method handles which permute their arguments * @library /test/lib /java/lang/invoke/common - * @run testng/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest + * @run junit/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest */ /* Examples of manual runs: @@ -35,7 +35,6 @@ package test.java.lang.invoke; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.CodeCacheOverflowProcessor; import java.lang.invoke.MethodHandle; @@ -52,6 +51,10 @@ import static java.lang.invoke.MethodHandles.Lookup; import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.permuteArguments; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class PermuteArgsTest { private static final Class CLASS = PermuteArgsTest.class; @@ -259,11 +262,11 @@ public class PermuteArgsTest { reverse(perm, 0, perm.length); } switch (perm.length) { - case 2: assert(testCases - testCases0 == 2); break; - case 3: assert(testCases - testCases0 == 6); break; - case 4: assert(testCases - testCases0 == 24); break; - case 5: assert(testCases - testCases0 == 120); break; - case 6: assert(testCases - testCases0 > 720/3); break; + case 2 -> assertEquals(2, testCases - testCases0); + case 3 -> assertEquals(6, testCases - testCases0); + case 4 -> assertEquals(24, testCases - testCases0); + case 5 -> assertEquals(120, testCases - testCases0); + case 6 -> assertTrue(testCases - testCases0 > 720/3); } } diff --git a/test/jdk/java/lang/invoke/SpreadCollectTest.java b/test/jdk/java/lang/invoke/SpreadCollectTest.java index bcddcd449f8..d58ebab3611 100644 --- a/test/jdk/java/lang/invoke/SpreadCollectTest.java +++ b/test/jdk/java/lang/invoke/SpreadCollectTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @bug 8139885 * @bug 8143798 - * @run testng/othervm -ea -esa test.java.lang.invoke.SpreadCollectTest + * @run junit/othervm -ea -esa test.java.lang.invoke.SpreadCollectTest */ package test.java.lang.invoke; @@ -39,9 +39,11 @@ import java.util.*; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests for the new asSpreader/asCollector API added in JEP 274. @@ -51,14 +53,14 @@ public class SpreadCollectTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testAsSpreader() throws Throwable { + public void testAsSpreader() throws Throwable { MethodHandle spreader = SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 3); assertEquals(SpreadCollect.MT_spreader, spreader.type()); assertEquals("A456B", (String) spreader.invoke("A", new int[]{4, 5, 6}, "B")); } @Test - public static void testAsSpreaderExample() throws Throwable { + public void testAsSpreaderExample() throws Throwable { // test the JavaDoc asSpreader-with-pos example MethodHandle compare = LOOKUP.findStatic(Objects.class, "compare", methodType(int.class, Object.class, Object.class, Comparator.class)); MethodHandle compare2FromArray = compare.asSpreader(0, Object[].class, 2); @@ -66,49 +68,43 @@ public class SpreadCollectTest { Comparator cmp = (a, b) -> a - b; assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 0, 2), cmp) < 0); assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 1, 3), cmp) > 0); - assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp) == 0); + assertEquals(0, (int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp)); } - @DataProvider static Object[][] asSpreaderIllegalPositions() { return new Object[][]{{-7}, {3}, {19}}; } - @Test(dataProvider = "asSpreaderIllegalPositions") - public static void testAsSpreaderIllegalPos(int p) throws Throwable { - boolean caught = false; - try { - SpreadCollect.MH_forSpreading.asSpreader(p, Object[].class, 3); - } catch (IllegalArgumentException iae) { - assertEquals("bad spread position", iae.getMessage()); - caught = true; - } - assertTrue(caught); - } - - @Test(expectedExceptions = {WrongMethodTypeException.class}) - public static void testAsSpreaderIllegalMethodType() { - MethodHandle h = MethodHandles.dropArguments(MethodHandles.constant(String.class, ""), 0, int.class, int.class); - MethodHandle s = h.asSpreader(String[].class, 1); - } - - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderNullArrayType() { - SpreadCollect.MH_forSpreading.asSpreader(null, 0); - } - - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderNullArrayNonZeroLength() { - SpreadCollect.MH_forSpreading.asSpreader(null, 1); - } - - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderTooManyParams() throws Throwable { - SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 6); + @ParameterizedTest + @MethodSource("asSpreaderIllegalPositions") + public void testAsSpreaderIllegalPos(int p) throws Throwable { + var iae = assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(p, Object[].class, 3)); + assertEquals("bad spread position", iae.getMessage()); } @Test - public static void testAsCollector() throws Throwable { + public void testAsSpreaderIllegalMethodType() { + MethodHandle h = MethodHandles.dropArguments(MethodHandles.constant(String.class, ""), 0, int.class, int.class); + assertThrows(WrongMethodTypeException.class, () -> h.asSpreader(String[].class, 1)); + } + + @Test + public void testAsSpreaderNullArrayType() { + assertThrows(NullPointerException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(null, 0)); + } + + @Test + public void testAsSpreaderNullArrayNonZeroLength() { + assertThrows(NullPointerException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(null, 1)); + } + + @Test + public void testAsSpreaderTooManyParams() throws Throwable { + assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 6)); + } + + @Test + public void testAsCollector() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 1); assertEquals(SpreadCollect.MT_collector1, collector.type()); assertEquals("A4B", (String) collector.invoke("A", 4, "B")); @@ -121,7 +117,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorInvokeWithArguments() throws Throwable { + public void testAsCollectorInvokeWithArguments() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 1); assertEquals(SpreadCollect.MT_collector1, collector.type()); assertEquals("A4B", (String) collector.invokeWithArguments("A", 4, "B")); @@ -134,7 +130,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorLeading() throws Throwable { + public void testAsCollectorLeading() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollectingLeading.asCollector(0, int[].class, 1); assertEquals(SpreadCollect.MT_collectorLeading1, collector.type()); assertEquals("7Q", (String) collector.invoke(7, "Q")); @@ -147,7 +143,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorLeadingInvokeWithArguments() throws Throwable { + public void testAsCollectorLeadingInvokeWithArguments() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollectingLeading.asCollector(0, int[].class, 1); assertEquals(SpreadCollect.MT_collectorLeading1, collector.type()); assertEquals("7Q", (String) collector.invokeWithArguments(7, "Q")); @@ -160,31 +156,25 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorNone() throws Throwable { + public void testAsCollectorNone() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 0); assertEquals(SpreadCollect.MT_collector0, collector.type()); assertEquals("AB", (String) collector.invoke("A", "B")); } - @DataProvider static Object[][] asCollectorIllegalPositions() { return new Object[][]{{-1}, {17}}; } - @Test(dataProvider = "asCollectorIllegalPositions") - public static void testAsCollectorIllegalPos(int p) { - boolean caught = false; - try { - SpreadCollect.MH_forCollecting.asCollector(p, int[].class, 0); - } catch (IllegalArgumentException iae) { - assertEquals("bad collect position", iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("asCollectorIllegalPositions") + public void testAsCollectorIllegalPos(int p) { + var iae = assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forCollecting.asCollector(p, int[].class, 0)); + assertEquals("bad collect position", iae.getMessage()); } @Test - public static void testAsCollectorExample() throws Throwable { + public void testAsCollectorExample() throws Throwable { // test the JavaDoc asCollector-with-pos example StringWriter swr = new StringWriter(); MethodHandle swWrite = LOOKUP. diff --git a/test/jdk/java/lang/invoke/TestVHInvokerCaching.java b/test/jdk/java/lang/invoke/TestVHInvokerCaching.java index 0a1ae5914ca..e5c7d50daa7 100644 --- a/test/jdk/java/lang/invoke/TestVHInvokerCaching.java +++ b/test/jdk/java/lang/invoke/TestVHInvokerCaching.java @@ -23,12 +23,9 @@ /* @test * @bug 8265079 - * @run testng/othervm -Xverify:all TestVHInvokerCaching + * @run junit/othervm -Xverify:all TestVHInvokerCaching */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; @@ -37,12 +34,16 @@ import java.util.ArrayList; import java.util.List; import static java.lang.invoke.MethodHandles.lookup; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestVHInvokerCaching { - @Test(dataProvider = "testHandles") - public static void testVHIInvokerCaching(VarHandle testHandle) throws Throwable { + @ParameterizedTest + @MethodSource("testHandles") + public void testVHIInvokerCaching(VarHandle testHandle) throws Throwable { for (VarHandle.AccessMode mode : VarHandle.AccessMode.values()) { MethodHandle handle1 = MethodHandles.varHandleInvoker(mode, testHandle.accessModeType(mode)); MethodHandle handle2 = MethodHandles.varHandleInvoker(mode, testHandle.accessModeType(mode)); @@ -56,7 +57,6 @@ public class TestVHInvokerCaching { } } - @DataProvider public static Object[][] testHandles() throws NoSuchFieldException, IllegalAccessException { List testHandles = new ArrayList<>(); diff --git a/test/jdk/java/lang/invoke/ThrowExceptionsTest.java b/test/jdk/java/lang/invoke/ThrowExceptionsTest.java index e12bb7040c4..627a056faec 100644 --- a/test/jdk/java/lang/invoke/ThrowExceptionsTest.java +++ b/test/jdk/java/lang/invoke/ThrowExceptionsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, 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 @@ -23,14 +23,11 @@ /* @test * @summary unit tests for method handles which permute their arguments - * @run testng test.java.lang.invoke.ThrowExceptionsTest + * @run junit test.java.lang.invoke.ThrowExceptionsTest */ package test.java.lang.invoke; -import org.testng.*; -import org.testng.annotations.*; - import java.util.*; import java.lang.reflect.*; @@ -38,6 +35,10 @@ import java.lang.invoke.*; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class ThrowExceptionsTest { private static final Class CLASS = ThrowExceptionsTest.class; private static final Lookup LOOKUP = lookup(); @@ -51,7 +52,7 @@ public class ThrowExceptionsTest { // mostly call testWMTCallee, but sometimes call its void-returning variant MethodHandle mh = testWMTCallee(); MethodHandle mh1 = mh.asType(mh.type().changeReturnType(void.class)); - assert(mh1 != mh); + assertNotSame(mh, mh1); testWMT(mh, mh1, 1000); } @@ -108,7 +109,7 @@ public class ThrowExceptionsTest { MethodHandle[] cell = { null }; // recursion point MethodHandle getCell = insertArguments(arrayElementGetter(cell.getClass()), 0, cell, 0); MethodHandle invokeCell = foldArguments(exactInvoker(cellType), getCell); - assert(invokeCell.type() == cellType); + assertSame(cellType, invokeCell.type()); cell[0] = invokeCell; // make it conformable to any type: invokeCell = dropArguments(invokeCell, 0, Object[].class).asVarargsCollector(Object[].class); @@ -189,7 +190,6 @@ public class ThrowExceptionsTest { try { // FIXME: should not have to retype this n = (int) mh.invokeExact((Object)this, "x"); - assertEquals(n, i - catches); // Using the exact type for this causes endless deopt due to // 'non_cached_result' in SystemDictionary::find_method_handle_invoke. // The problem is that the compiler thread needs to access a cached @@ -198,7 +198,9 @@ public class ThrowExceptionsTest { } catch (Exception ex) { savedEx = ex; catches++; + continue; } + assertEquals(i - catches, n); } //VERBOSE: System.out.println("reps="+reps+" catches="+catches); return savedEx; @@ -220,9 +222,4 @@ public class ThrowExceptionsTest { } return savedEx; } - - private static void assertEquals(Object x, Object y) { - if (x == y || x != null && x.equals(y)) return; - throw new RuntimeException(x+" != "+y); - } } diff --git a/test/jdk/java/lang/invoke/TryFinallyTest.java b/test/jdk/java/lang/invoke/TryFinallyTest.java index 4a3c255201e..ebe276ede93 100644 --- a/test/jdk/java/lang/invoke/TryFinallyTest.java +++ b/test/jdk/java/lang/invoke/TryFinallyTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -23,7 +23,7 @@ /* @test * @bug 8139885 8150824 8150825 8194238 8233920 - * @run testng/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest + * @run junit/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest */ package test.java.lang.invoke; @@ -35,9 +35,12 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; /** * Tests for the tryFinally method handle combinator introduced in JEP 274. @@ -47,13 +50,12 @@ public class TryFinallyTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testTryFinally() throws Throwable { + public void testTryFinally() throws Throwable { MethodHandle hello = MethodHandles.tryFinally(TryFinally.MH_greet, TryFinally.MH_exclaim); assertEquals(TryFinally.MT_hello, hello.type()); assertEquals("Hello, world!", hello.invoke("world")); } - @DataProvider static Object[][] tryFinallyArgs() { return new Object[][] { { boolean.class, true }, @@ -68,8 +70,9 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "tryFinallyArgs") - public static void testTryFinally(Class argType, Object arg) throws Throwable { + @ParameterizedTest + @MethodSource("tryFinallyArgs") + public void testTryFinally(Class argType, Object arg) throws Throwable { MethodHandle identity = MethodHandles.identity(argType); MethodHandle tryFinally = MethodHandles.tryFinally( identity, @@ -78,31 +81,31 @@ public class TryFinallyTest { assertEquals(arg, tryFinally.invoke(arg)); } - @Test(dataProvider = "tryFinallyArgs", expectedExceptions = TryFinally.T1.class) - public static void testTryFinallyException(Class argType, Object arg) throws Throwable { + @ParameterizedTest + @MethodSource("tryFinallyArgs") + public void testTryFinallyException(Class argType, Object arg) throws Throwable { MethodHandle identity = TryFinally.MH_throwingTargetIdentity.asType(methodType(argType, argType)); MethodHandle tryFinally = MethodHandles.tryFinally( identity, MethodHandles.dropArguments(identity, 0, TryFinally.T1.class)); assertEquals(methodType(argType, argType), tryFinally.type()); - tryFinally.invoke(arg); // should throw + assertThrows(TryFinally.T1.class, () -> tryFinally.invoke(arg)); } @Test - public static void testTryFinallyVoid() throws Throwable { + public void testTryFinallyVoid() throws Throwable { MethodHandle tfVoid = MethodHandles.tryFinally(TryFinally.MH_print, TryFinally.MH_printMore); assertEquals(TryFinally.MT_printHello, tfVoid.type()); tfVoid.invoke("world"); } @Test - public static void testTryFinallySublist() throws Throwable { + public void testTryFinallySublist() throws Throwable { MethodHandle helloMore = MethodHandles.tryFinally(TryFinally.MH_greetMore, TryFinally.MH_exclaimMore); assertEquals(TryFinally.MT_moreHello, helloMore.type()); assertEquals("Hello, world and universe (but world first)!", helloMore.invoke("world", "universe")); } - @DataProvider static Object[][] omitTrailingArguments() { MethodHandle c = TryFinally.MH_voidCleanup; return new Object[][]{ @@ -114,13 +117,13 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "omitTrailingArguments") - public static void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable { + @ParameterizedTest + @MethodSource("omitTrailingArguments") + public void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable { MethodHandle tf = MethodHandles.tryFinally(TryFinally.MH_dummyTarget, cleanup); tf.invoke(1, 2L, "a", 23, 42L, "b"); } - @DataProvider static Object[][] negativeTestData() { MethodHandle intid = MethodHandles.identity(int.class); MethodHandle intco = MethodHandles.constant(int.class, 0); @@ -145,29 +148,18 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "negativeTestData") - public static void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) { - boolean caught = false; - try { - MethodHandles.tryFinally(target, cleanup); - } catch (IllegalArgumentException iae) { - assertEquals(expectedMessage, iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("negativeTestData") + public void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) { + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.tryFinally(target, cleanup)); + assertEquals(expectedMessage, iae.getMessage()); } @Test - public static void testTryFinallyThrowableCheck() { + public void testTryFinallyThrowableCheck() { MethodHandle mh = MethodHandles.tryFinally(TryFinally.MH_throwingTarget, TryFinally.MH_catchingCleanup); - try { - mh.invoke(); - fail("ClassCastException expected"); - } catch (Throwable t) { - assertTrue("Throwable not assignable to ClassCastException: " + t, - ClassCastException.class.isAssignableFrom(t.getClass())); - } + assertThrows(ClassCastException.class, mh::invoke); } static class TryFinally { diff --git a/test/jdk/java/lang/invoke/VarArgsTest.java b/test/jdk/java/lang/invoke/VarArgsTest.java index bb17881b514..bcea9a0b54e 100644 --- a/test/jdk/java/lang/invoke/VarArgsTest.java +++ b/test/jdk/java/lang/invoke/VarArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -23,19 +23,18 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng/othervm -ea -esa test.java.lang.invoke.VarArgsTest + * @run junit/othervm -ea -esa test.java.lang.invoke.VarArgsTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; -import java.lang.invoke.MethodHandles; -import java.lang.invoke.MethodType; import java.util.Arrays; import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class VarArgsTest { @@ -61,17 +60,17 @@ public class VarArgsTest { MethodHandle asList = publicLookup() .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)); MethodHandle asListWithVarargs = asList.withVarargs(asList.isVarargsCollector()); - assert(asListWithVarargs.isVarargsCollector()); + assertTrue(asListWithVarargs.isVarargsCollector()); assertEquals("[]", asListWithVarargs.invoke().toString()); assertEquals("[1]", asListWithVarargs.invoke(1).toString()); assertEquals("[two, too]", asListWithVarargs.invoke("two", "too").toString()); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testWithVarargsIAE() throws Throwable { MethodHandle lenMH = publicLookup() - .findVirtual(String.class, "length", methodType(int.class)); - MethodHandle lenMHWithVarargs = lenMH.withVarargs(true); + .findVirtual(String.class, "length", methodType(int.class)); + assertThrows(IllegalArgumentException.class, () -> lenMH.withVarargs(true)); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java index f09ba518e48..c89fcc8289b 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -21,9 +21,6 @@ * questions. */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; - import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; @@ -32,6 +29,7 @@ import java.util.Arrays; import java.util.EnumSet; import java.util.List; import java.util.function.Function; +import org.junit.jupiter.api.BeforeAll; public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { @@ -338,7 +336,7 @@ public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { bavss.add(dbb_offset_unaligned_ro); } - @BeforeClass + @BeforeAll public void setup() { setupByteSources(); vhss = setupVarHandleSources(true); @@ -346,13 +344,10 @@ public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { abstract List setupVarHandleSources(boolean same); - - @DataProvider public Object[][] varHandlesProvider() throws Exception { return vhss.stream().map(cvh -> new Object[]{cvh}).toArray(Object[][]::new); } - @DataProvider public Object[][] typesProvider() throws Exception { List> aepts = Arrays.asList(byte[].class, int.class); List> bbpts = Arrays.asList(ByteBuffer.class, int.class); diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java index 0c9a7fd3953..0e029b8f5f7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -36,7 +36,7 @@ import java.util.Map; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; abstract class VarHandleBaseTest { static final int ITERS = Integer.getInteger("iters", 1); @@ -136,18 +136,7 @@ abstract class VarHandleBaseTest { static void checkWithThrowable(Class re, Object message, ThrowingRunnable r) { - Throwable _e = null; - try { - r.run(); - } - catch (Throwable e) { - _e = e; - } - message = message == null ? "" : message + ". "; - assertNotNull(_e, String.format("%sNo throwable thrown. Expected %s", message, re)); - if (!re.isInstance(_e)) { - fail(String.format("%sIncorrect throwable thrown, %s. Expected %s", message, _e, re), _e); - } + assertThrows(re, r::run, message == null ? null : message.toString()); } @@ -277,11 +266,11 @@ abstract class VarHandleBaseTest { } private static MethodHandle bind(VarHandle vh, MethodHandle mh, MethodType emt) { - assertEquals(mh.type(), emt.insertParameterTypes(0, VarHandle.class), + assertEquals(emt.insertParameterTypes(0, VarHandle.class), mh.type(), "MethodHandle type differs from access mode type"); MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - assertEquals(info.getMethodType(), emt, + assertEquals(emt, info.getMethodType(), "MethodHandleInfo method type differs from access mode type"); return mh.bindTo(vh); @@ -472,39 +461,39 @@ abstract class VarHandleBaseTest { for (TestAccessMode accessMode : testAccessModes()) { MethodType amt = vh.accessModeType(accessMode.toAccessMode()); - assertEquals(amt.parameterList().subList(0, pts.size()), pts); + assertEquals(pts, amt.parameterList().subList(0, pts.size())); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.GET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterList(), pts); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(pts, mt.parameterList()); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.SET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), void.class); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); + assertEquals(void.class, mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), boolean.class); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 2), vh.varType()); + assertEquals(boolean.class, mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 2)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 2), vh.varType()); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 2)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.GET_AND_SET, TestAccessType.GET_AND_ADD)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java index 02de5a3e186..23e46096073 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, 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 @@ -25,12 +25,12 @@ * @test * @bug 8195650 * @summary Test linking of method references to VarHandle access methods. - * @run testng VarHandleMethodReferenceTest + * @run junit VarHandleMethodReferenceTest */ -import org.testng.annotations.Test; import java.lang.invoke.*; +import org.junit.jupiter.api.Test; public class VarHandleMethodReferenceTest { diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java index a9cd5a61655..548e008b09e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessBoolean + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessBoolean * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessBoolean - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessBoolean - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -108,7 +110,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessBoolean.class, "final_v", boolean.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessBoolean.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), boolean.class); + assertEquals(boolean.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { // Plain { boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } // Volatile { boolean x = (boolean) vh.getVolatile(recv); - assertEquals(x, true, "getVolatile boolean value"); + assertEquals(true, x, "getVolatile boolean value"); } // Lazy { boolean x = (boolean) vh.getAcquire(recv); - assertEquals(x, true, "getRelease boolean value"); + assertEquals(true, x, "getRelease boolean value"); } // Opaque { boolean x = (boolean) vh.getOpaque(recv); - assertEquals(x, true, "getOpaque boolean value"); + assertEquals(true, x, "getOpaque boolean value"); } } @@ -357,26 +355,26 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { // Plain { boolean x = (boolean) vh.get(); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } // Volatile { boolean x = (boolean) vh.getVolatile(); - assertEquals(x, true, "getVolatile boolean value"); + assertEquals(true, x, "getVolatile boolean value"); } // Lazy { boolean x = (boolean) vh.getAcquire(); - assertEquals(x, true, "getRelease boolean value"); + assertEquals(true, x, "getRelease boolean value"); } // Opaque { boolean x = (boolean) vh.getOpaque(); - assertEquals(x, true, "getOpaque boolean value"); + assertEquals(true, x, "getOpaque boolean value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(recv, true); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -426,21 +424,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(recv, false); boolean x = (boolean) vh.getVolatile(recv); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(recv, true); boolean x = (boolean) vh.getAcquire(recv); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(recv, false); boolean x = (boolean) vh.getOpaque(recv); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(recv, true); @@ -450,56 +448,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(recv, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(recv, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(recv, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(recv, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(recv, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(recv, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(recv, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -510,14 +508,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -528,14 +526,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(recv, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -546,14 +544,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -564,14 +562,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success weakCompareAndSet boolean value"); + assertEquals(true, x, "success weakCompareAndSet boolean value"); } { boolean success = vh.weakCompareAndSet(recv, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -579,27 +577,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndSet(recv, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndSetAcquire(recv, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndSetRelease(recv, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -608,27 +606,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOr(recv, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOrRelease(recv, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -636,27 +634,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAnd(recv, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAndRelease(recv, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -664,27 +662,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXor(recv, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXorRelease(recv, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -710,7 +708,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(true); boolean x = (boolean) vh.get(); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -718,21 +716,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(false); boolean x = (boolean) vh.getVolatile(); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(true); boolean x = (boolean) vh.getAcquire(); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(false); boolean x = (boolean) vh.getOpaque(); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(true); @@ -742,56 +740,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -802,14 +800,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -820,14 +818,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -838,14 +836,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -856,14 +854,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = vh.weakCompareAndSet(false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -871,27 +869,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndSet(false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndSetAcquire(false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndSetRelease(false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -900,27 +898,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOr(false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOrRelease(false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -928,27 +926,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAnd(false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAndRelease(false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -956,27 +954,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXor(false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXorRelease(false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -1005,7 +1003,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(array, i, true); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } @@ -1013,21 +1011,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(array, i, false); boolean x = (boolean) vh.getVolatile(array, i); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(array, i, true); boolean x = (boolean) vh.getAcquire(array, i); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(array, i, false); boolean x = (boolean) vh.getOpaque(array, i); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(array, i, true); @@ -1037,56 +1035,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(array, i, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(array, i, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(array, i, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(array, i, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(array, i, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(array, i, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(array, i, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -1097,14 +1095,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -1115,14 +1113,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -1133,14 +1131,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -1151,14 +1149,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = vh.weakCompareAndSet(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -1166,27 +1164,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndSet(array, i, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndSetAcquire(array, i, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndSetRelease(array, i, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -1195,27 +1193,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOr(array, i, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOrRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -1223,27 +1221,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAnd(array, i, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAndRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -1251,27 +1249,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXor(array, i, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXorRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java index 5dc4bf2d1d5..42c465af75e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessByte + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessByte * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessByte - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessByte - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -108,7 +110,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessByte.class, "final_v", byte.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessByte.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), byte.class); + assertEquals(byte.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { // Plain { byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } // Volatile { byte x = (byte) vh.getVolatile(recv); - assertEquals(x, (byte)0x01, "getVolatile byte value"); + assertEquals((byte)0x01, x, "getVolatile byte value"); } // Lazy { byte x = (byte) vh.getAcquire(recv); - assertEquals(x, (byte)0x01, "getRelease byte value"); + assertEquals((byte)0x01, x, "getRelease byte value"); } // Opaque { byte x = (byte) vh.getOpaque(recv); - assertEquals(x, (byte)0x01, "getOpaque byte value"); + assertEquals((byte)0x01, x, "getOpaque byte value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { // Plain { byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } // Volatile { byte x = (byte) vh.getVolatile(); - assertEquals(x, (byte)0x01, "getVolatile byte value"); + assertEquals((byte)0x01, x, "getVolatile byte value"); } // Lazy { byte x = (byte) vh.getAcquire(); - assertEquals(x, (byte)0x01, "getRelease byte value"); + assertEquals((byte)0x01, x, "getRelease byte value"); } // Opaque { byte x = (byte) vh.getOpaque(); - assertEquals(x, (byte)0x01, "getOpaque byte value"); + assertEquals((byte)0x01, x, "getOpaque byte value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set(recv, (byte)0x01); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile(recv, (byte)0x23); byte x = (byte) vh.getVolatile(recv); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease(recv, (byte)0x01); byte x = (byte) vh.getAcquire(recv); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque(recv, (byte)0x23); byte x = (byte) vh.getOpaque(recv); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set(recv, (byte)0x01); @@ -428,56 +426,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte value"); } { boolean success = vh.weakCompareAndSet(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSet(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSetAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSetRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAdd(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAddAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAddRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOr(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAnd(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXor(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set((byte)0x01); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile((byte)0x23); byte x = (byte) vh.getVolatile(); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease((byte)0x01); byte x = (byte) vh.getAcquire(); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque((byte)0x23); byte x = (byte) vh.getOpaque(); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set((byte)0x01); @@ -736,56 +734,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet((byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet((byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = vh.weakCompareAndSet((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndSet((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndSetAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndSetRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndAdd((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndAddAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndAddRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOr((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAnd((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXor((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set(array, i, (byte)0x01); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile(array, i, (byte)0x23); byte x = (byte) vh.getVolatile(array, i); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease(array, i, (byte)0x01); byte x = (byte) vh.getAcquire(array, i); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque(array, i, (byte)0x23); byte x = (byte) vh.getOpaque(array, i); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set(array, i, (byte)0x01); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = vh.weakCompareAndSet(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSet(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSetAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSetRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAdd(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAddAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAddRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOr(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAnd(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXor(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java index bafde057167..e17e7616609 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessChar + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessChar * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessChar - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessChar - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -108,7 +110,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessChar.class, "final_v", char.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessChar.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), char.class); + assertEquals(char.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { // Plain { char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } // Volatile { char x = (char) vh.getVolatile(recv); - assertEquals(x, '\u0123', "getVolatile char value"); + assertEquals('\u0123', x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(recv); - assertEquals(x, '\u0123', "getRelease char value"); + assertEquals('\u0123', x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(recv); - assertEquals(x, '\u0123', "getOpaque char value"); + assertEquals('\u0123', x, "getOpaque char value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { // Plain { char x = (char) vh.get(); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } // Volatile { char x = (char) vh.getVolatile(); - assertEquals(x, '\u0123', "getVolatile char value"); + assertEquals('\u0123', x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(); - assertEquals(x, '\u0123', "getRelease char value"); + assertEquals('\u0123', x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(); - assertEquals(x, '\u0123', "getOpaque char value"); + assertEquals('\u0123', x, "getOpaque char value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set(recv, '\u0123'); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile(recv, '\u4567'); char x = (char) vh.getVolatile(recv); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease(recv, '\u0123'); char x = (char) vh.getAcquire(recv); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque(recv, '\u4567'); char x = (char) vh.getOpaque(recv); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set(recv, '\u0123'); @@ -428,56 +426,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet(recv, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire(recv, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire(recv, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success weakCompareAndSet char value"); + assertEquals('\u0123', x, "success weakCompareAndSet char value"); } { boolean success = vh.weakCompareAndSet(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndSet(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndSetAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndSetRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndAdd(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndAddAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndAddRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOr(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOrAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOrRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAnd(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAndAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAndRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXor(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXorAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXorRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set('\u0123'); char x = (char) vh.get(); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile('\u4567'); char x = (char) vh.getVolatile(); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease('\u0123'); char x = (char) vh.getAcquire(); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque('\u4567'); char x = (char) vh.getOpaque(); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set('\u0123'); @@ -736,56 +734,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet('\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet('\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire('\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire('\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = vh.weakCompareAndSet('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndSet('\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set('\u0123'); char o = (char) vh.getAndSetAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndSetRelease('\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndAdd('\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set('\u0123'); char o = (char) vh.getAndAddAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndAddRelease('\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOr('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOrAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOrRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAnd('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAndAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAndRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXor('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXorAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXorRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set(array, i, '\u0123'); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile(array, i, '\u4567'); char x = (char) vh.getVolatile(array, i); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease(array, i, '\u0123'); char x = (char) vh.getAcquire(array, i); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque(array, i, '\u4567'); char x = (char) vh.getOpaque(array, i); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set(array, i, '\u0123'); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet(array, i, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire(array, i, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire(array, i, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = vh.weakCompareAndSet(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSet(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSetAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSetRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAdd(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAddAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAddRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOr(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOrAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOrRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAnd(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAndAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAndRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXor(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXorAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXorRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java index 0edb196076c..29fa6c2886d 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessDouble + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessDouble * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessDouble - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessDouble - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -108,7 +110,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessDouble.class, "final_v", double.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessDouble.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), double.class); + assertEquals(double.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { // Plain { double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } // Volatile { double x = (double) vh.getVolatile(recv); - assertEquals(x, 1.0d, "getVolatile double value"); + assertEquals(1.0d, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(recv); - assertEquals(x, 1.0d, "getRelease double value"); + assertEquals(1.0d, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(recv); - assertEquals(x, 1.0d, "getOpaque double value"); + assertEquals(1.0d, x, "getOpaque double value"); } } @@ -381,26 +379,26 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { // Plain { double x = (double) vh.get(); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } // Volatile { double x = (double) vh.getVolatile(); - assertEquals(x, 1.0d, "getVolatile double value"); + assertEquals(1.0d, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(); - assertEquals(x, 1.0d, "getRelease double value"); + assertEquals(1.0d, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(); - assertEquals(x, 1.0d, "getOpaque double value"); + assertEquals(1.0d, x, "getOpaque double value"); } } @@ -466,7 +464,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(recv, 1.0d); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -474,21 +472,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(recv, 2.0d); double x = (double) vh.getVolatile(recv); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(recv, 1.0d); double x = (double) vh.getAcquire(recv); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(recv, 2.0d); double x = (double) vh.getOpaque(recv); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(recv, 1.0d); @@ -498,56 +496,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(recv, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(recv, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(recv, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -558,14 +556,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -576,14 +574,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -594,14 +592,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -612,14 +610,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success weakCompareAndSet double value"); + assertEquals(1.0d, x, "success weakCompareAndSet double value"); } { boolean success = vh.weakCompareAndSet(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -627,27 +625,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(recv, 1.0d); double o = (double) vh.getAndSet(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndSetAcquire(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndSetRelease(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -655,27 +653,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(recv, 1.0d); double o = (double) vh.getAndAdd(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndAddAcquire(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndAddRelease(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -726,7 +724,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(1.0d); double x = (double) vh.get(); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -734,21 +732,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(2.0d); double x = (double) vh.getVolatile(); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(1.0d); double x = (double) vh.getAcquire(); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(2.0d); double x = (double) vh.getOpaque(); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(1.0d); @@ -758,56 +756,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -818,14 +816,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -836,14 +834,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -854,14 +852,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -872,14 +870,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -887,27 +885,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(1.0d); double o = (double) vh.getAndSet(2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(1.0d); double o = (double) vh.getAndSetAcquire(2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(1.0d); double o = (double) vh.getAndSetRelease(2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -915,27 +913,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(1.0d); double o = (double) vh.getAndAdd(2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(1.0d); double o = (double) vh.getAndAddAcquire(2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(1.0d); double o = (double) vh.getAndAddRelease(2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -989,7 +987,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(array, i, 1.0d); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } @@ -997,21 +995,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(array, i, 2.0d); double x = (double) vh.getVolatile(array, i); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(array, i, 1.0d); double x = (double) vh.getAcquire(array, i); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(array, i, 2.0d); double x = (double) vh.getOpaque(array, i); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(array, i, 1.0d); @@ -1021,56 +1019,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(array, i, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -1081,14 +1079,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -1099,14 +1097,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -1117,14 +1115,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -1135,14 +1133,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -1150,27 +1148,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(array, i, 1.0d); double o = (double) vh.getAndSet(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndSetAcquire(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndSetRelease(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -1178,27 +1176,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(array, i, 1.0d); double o = (double) vh.getAndAdd(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndAddAcquire(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndAddRelease(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java index c77a8d68008..750a1bbc408 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessFloat + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessFloat * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessFloat - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessFloat - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -108,7 +110,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessFloat.class, "final_v", float.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessFloat.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), float.class); + assertEquals(float.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { // Plain { float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } // Volatile { float x = (float) vh.getVolatile(recv); - assertEquals(x, 1.0f, "getVolatile float value"); + assertEquals(1.0f, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(recv); - assertEquals(x, 1.0f, "getRelease float value"); + assertEquals(1.0f, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(recv); - assertEquals(x, 1.0f, "getOpaque float value"); + assertEquals(1.0f, x, "getOpaque float value"); } } @@ -381,26 +379,26 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { // Plain { float x = (float) vh.get(); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } // Volatile { float x = (float) vh.getVolatile(); - assertEquals(x, 1.0f, "getVolatile float value"); + assertEquals(1.0f, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(); - assertEquals(x, 1.0f, "getRelease float value"); + assertEquals(1.0f, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(); - assertEquals(x, 1.0f, "getOpaque float value"); + assertEquals(1.0f, x, "getOpaque float value"); } } @@ -466,7 +464,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(recv, 1.0f); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -474,21 +472,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(recv, 2.0f); float x = (float) vh.getVolatile(recv); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(recv, 1.0f); float x = (float) vh.getAcquire(recv); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(recv, 2.0f); float x = (float) vh.getOpaque(recv); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(recv, 1.0f); @@ -498,56 +496,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(recv, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -558,14 +556,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -576,14 +574,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -594,14 +592,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -612,14 +610,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success weakCompareAndSet float value"); + assertEquals(1.0f, x, "success weakCompareAndSet float value"); } { boolean success = vh.weakCompareAndSet(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -627,27 +625,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(recv, 1.0f); float o = (float) vh.getAndSet(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndSetAcquire(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndSetRelease(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -655,27 +653,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(recv, 1.0f); float o = (float) vh.getAndAdd(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndAddAcquire(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndAddRelease(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -726,7 +724,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(1.0f); float x = (float) vh.get(); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -734,21 +732,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(2.0f); float x = (float) vh.getVolatile(); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(1.0f); float x = (float) vh.getAcquire(); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(2.0f); float x = (float) vh.getOpaque(); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(1.0f); @@ -758,56 +756,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -818,14 +816,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -836,14 +834,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -854,14 +852,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -872,14 +870,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -887,27 +885,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(1.0f); float o = (float) vh.getAndSet(2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(1.0f); float o = (float) vh.getAndSetAcquire(2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(1.0f); float o = (float) vh.getAndSetRelease(2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -915,27 +913,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(1.0f); float o = (float) vh.getAndAdd(2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(1.0f); float o = (float) vh.getAndAddAcquire(2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(1.0f); float o = (float) vh.getAndAddRelease(2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -989,7 +987,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(array, i, 1.0f); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } @@ -997,21 +995,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(array, i, 2.0f); float x = (float) vh.getVolatile(array, i); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(array, i, 1.0f); float x = (float) vh.getAcquire(array, i); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(array, i, 2.0f); float x = (float) vh.getOpaque(array, i); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(array, i, 1.0f); @@ -1021,56 +1019,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(array, i, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -1081,14 +1079,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -1099,14 +1097,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -1117,14 +1115,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -1135,14 +1133,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -1150,27 +1148,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(array, i, 1.0f); float o = (float) vh.getAndSet(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndSetAcquire(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndSetRelease(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -1178,27 +1176,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(array, i, 1.0f); float o = (float) vh.getAndAdd(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndAddAcquire(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndAddRelease(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java index d5dfaa4e1c6..4748d699555 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessInt + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessInt * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessInt - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -108,7 +110,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessInt.class, "final_v", int.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessInt.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), int.class); + assertEquals(int.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { // Plain { int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } // Volatile { int x = (int) vh.getVolatile(recv); - assertEquals(x, 0x01234567, "getVolatile int value"); + assertEquals(0x01234567, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(recv); - assertEquals(x, 0x01234567, "getRelease int value"); + assertEquals(0x01234567, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(recv); - assertEquals(x, 0x01234567, "getOpaque int value"); + assertEquals(0x01234567, x, "getOpaque int value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { // Plain { int x = (int) vh.get(); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } // Volatile { int x = (int) vh.getVolatile(); - assertEquals(x, 0x01234567, "getVolatile int value"); + assertEquals(0x01234567, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(); - assertEquals(x, 0x01234567, "getRelease int value"); + assertEquals(0x01234567, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(); - assertEquals(x, 0x01234567, "getOpaque int value"); + assertEquals(0x01234567, x, "getOpaque int value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(recv, 0x01234567); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(recv, 0x89ABCDEF); int x = (int) vh.getVolatile(recv); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(recv, 0x01234567); int x = (int) vh.getAcquire(recv); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(recv, 0x89ABCDEF); int x = (int) vh.getOpaque(recv); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(recv, 0x01234567); @@ -428,56 +426,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSet int value"); + assertEquals(0x01234567, x, "success weakCompareAndSet int value"); } { boolean success = vh.weakCompareAndSet(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndSet(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndSetAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndSetRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndAdd(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndAddAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndAddRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOr(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOrRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAnd(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAndRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXor(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXorRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(0x01234567); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(0x89ABCDEF); int x = (int) vh.getVolatile(); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(0x01234567); int x = (int) vh.getAcquire(); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(0x89ABCDEF); int x = (int) vh.getOpaque(); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(0x01234567); @@ -736,56 +734,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndSet(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(0x01234567); int o = (int) vh.getAndSetAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndSetRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndAdd(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(0x01234567); int o = (int) vh.getAndAddAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndAddRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOr(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOrRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAnd(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAndRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXor(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXorRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(array, i, 0x01234567); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(array, i, 0x89ABCDEF); int x = (int) vh.getVolatile(array, i); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(array, i, 0x01234567); int x = (int) vh.getAcquire(array, i); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(array, i, 0x89ABCDEF); int x = (int) vh.getOpaque(array, i); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(array, i, 0x01234567); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSet(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSetAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSetRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAdd(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAddAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAddRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOr(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOrRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAnd(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAndRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXor(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXorRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java index e40256a8bd5..8bf997bb9a6 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessLong + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessLong * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessLong - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessLong - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -108,7 +110,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessLong.class, "final_v", long.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessLong.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), long.class); + assertEquals(long.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { // Plain { long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } // Volatile { long x = (long) vh.getVolatile(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value"); + assertEquals(0x0123456789ABCDEFL, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value"); + assertEquals(0x0123456789ABCDEFL, x, "getOpaque long value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { // Plain { long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } // Volatile { long x = (long) vh.getVolatile(); - assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value"); + assertEquals(0x0123456789ABCDEFL, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(); - assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(); - assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value"); + assertEquals(0x0123456789ABCDEFL, x, "getOpaque long value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(recv, 0x0123456789ABCDEFL); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(recv, 0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(recv, 0x0123456789ABCDEFL); long x = (long) vh.getAcquire(recv); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(recv, 0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(recv, 0x0123456789ABCDEFL); @@ -428,56 +426,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long value"); } { boolean success = vh.weakCompareAndSet(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSet(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(0x0123456789ABCDEFL); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(0x0123456789ABCDEFL); long x = (long) vh.getAcquire(); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(0x0123456789ABCDEFL); @@ -736,56 +734,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSet(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(array, i, 0x0123456789ABCDEFL); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(array, i, 0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(array, i, 0x0123456789ABCDEFL); long x = (long) vh.getAcquire(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(array, i, 0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(array, i, 0x0123456789ABCDEFL); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSet(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java index 3365bd923bc..61fc8a53fd0 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, 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 @@ -23,32 +23,34 @@ /* * @test - * @run testng VarHandleTestAccessModeMethodNames + * @run junit VarHandleTestAccessModeMethodNames * @modules java.base/java.lang.invoke:open */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.stream.Stream; -import static org.testng.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessModeMethodNames { - @DataProvider public static Object[][] accessModesProvider() { return Stream.of(VarHandle.AccessMode.values()). map(am -> new Object[]{am}). toArray(Object[][]::new); } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void testMethodName(VarHandle.AccessMode am) { - assertEquals(am.methodName(), toMethodName(am.name())); + assertEquals(toMethodName(am.name()), am.methodName()); } private static String toMethodName(String name) { @@ -62,9 +64,10 @@ public class VarHandleTestAccessModeMethodNames { } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void testReturnType(VarHandle.AccessMode am) throws Exception { - assertEquals(getReturnType(am.methodName()), getAccessModeReturnType(am)); + assertEquals(getAccessModeReturnType(am), getReturnType(am.methodName())); } private static Class getReturnType(String name) throws Exception { diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java index b9daf4880a0..552672c7372 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessShort + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessShort * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessShort - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -108,7 +110,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessShort.class, "final_v", short.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessShort.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), short.class); + assertEquals(short.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { // Plain { short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } // Volatile { short x = (short) vh.getVolatile(recv); - assertEquals(x, (short)0x0123, "getVolatile short value"); + assertEquals((short)0x0123, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(recv); - assertEquals(x, (short)0x0123, "getRelease short value"); + assertEquals((short)0x0123, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(recv); - assertEquals(x, (short)0x0123, "getOpaque short value"); + assertEquals((short)0x0123, x, "getOpaque short value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { // Plain { short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } // Volatile { short x = (short) vh.getVolatile(); - assertEquals(x, (short)0x0123, "getVolatile short value"); + assertEquals((short)0x0123, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(); - assertEquals(x, (short)0x0123, "getRelease short value"); + assertEquals((short)0x0123, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(); - assertEquals(x, (short)0x0123, "getOpaque short value"); + assertEquals((short)0x0123, x, "getOpaque short value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set(recv, (short)0x0123); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile(recv, (short)0x4567); short x = (short) vh.getVolatile(recv); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease(recv, (short)0x0123); short x = (short) vh.getAcquire(recv); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque(recv, (short)0x4567); short x = (short) vh.getOpaque(recv); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set(recv, (short)0x0123); @@ -428,56 +426,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet(recv, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire(recv, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire(recv, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short value"); } { boolean success = vh.weakCompareAndSet(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSet(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSetAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSetRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAdd(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAddAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAddRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOr(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOrRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAnd(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAndRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXor(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXorRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set((short)0x0123); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile((short)0x4567); short x = (short) vh.getVolatile(); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease((short)0x0123); short x = (short) vh.getAcquire(); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque((short)0x4567); short x = (short) vh.getOpaque(); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set((short)0x0123); @@ -736,56 +734,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet((short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet((short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire((short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire((short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = vh.weakCompareAndSet((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndSet((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndSetAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndSetRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndAdd((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndAddAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndAddRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOr((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOrRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAnd((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAndRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXor((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXorRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set(array, i, (short)0x0123); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile(array, i, (short)0x4567); short x = (short) vh.getVolatile(array, i); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease(array, i, (short)0x0123); short x = (short) vh.getAcquire(array, i); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque(array, i, (short)0x4567); short x = (short) vh.getOpaque(array, i); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set(array, i, (short)0x0123); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire(array, i, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = vh.weakCompareAndSet(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSet(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSetAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSetRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAdd(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAddAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAddRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOr(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOrRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAnd(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAndRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXor(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXorRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java index 8bc30739660..d1a746ba80e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessString + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessString * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessString - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessString - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -109,7 +111,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessString.class, "final_v", String.class); @@ -127,8 +129,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vhArrayObject = MethodHandles.arrayElementVarHandle(Object[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -158,7 +158,8 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -196,8 +197,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessString.class)}); @@ -207,16 +206,16 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), String.class); + assertEquals(String.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -243,8 +242,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -291,7 +288,8 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -304,26 +302,26 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { // Plain { String x = (String) vh.get(recv); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } // Volatile { String x = (String) vh.getVolatile(recv); - assertEquals(x, "foo", "getVolatile String value"); + assertEquals("foo", x, "getVolatile String value"); } // Lazy { String x = (String) vh.getAcquire(recv); - assertEquals(x, "foo", "getRelease String value"); + assertEquals("foo", x, "getRelease String value"); } // Opaque { String x = (String) vh.getOpaque(recv); - assertEquals(x, "foo", "getOpaque String value"); + assertEquals("foo", x, "getOpaque String value"); } } @@ -399,26 +397,26 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { // Plain { String x = (String) vh.get(); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } // Volatile { String x = (String) vh.getVolatile(); - assertEquals(x, "foo", "getVolatile String value"); + assertEquals("foo", x, "getVolatile String value"); } // Lazy { String x = (String) vh.getAcquire(); - assertEquals(x, "foo", "getRelease String value"); + assertEquals("foo", x, "getRelease String value"); } // Opaque { String x = (String) vh.getOpaque(); - assertEquals(x, "foo", "getOpaque String value"); + assertEquals("foo", x, "getOpaque String value"); } } @@ -495,7 +493,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set(recv, "foo"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -503,21 +501,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile(recv, "bar"); String x = (String) vh.getVolatile(recv); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease(recv, "foo"); String x = (String) vh.getAcquire(recv); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque(recv, "bar"); String x = (String) vh.getOpaque(recv); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set(recv, "foo"); @@ -527,56 +525,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet(recv, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire(recv, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire(recv, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -587,14 +585,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -605,14 +603,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -623,14 +621,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -641,14 +639,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success weakCompareAndSet String value"); + assertEquals("foo", x, "success weakCompareAndSet String value"); } { boolean success = vh.weakCompareAndSet(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -656,27 +654,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set(recv, "foo"); String o = (String) vh.getAndSet(recv, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set(recv, "foo"); String o = (String) vh.getAndSetAcquire(recv, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set(recv, "foo"); String o = (String) vh.getAndSetRelease(recv, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -739,7 +737,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set("foo"); String x = (String) vh.get(); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -747,21 +745,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile("bar"); String x = (String) vh.getVolatile(); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease("foo"); String x = (String) vh.getAcquire(); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque("bar"); String x = (String) vh.getOpaque(); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set("foo"); @@ -771,56 +769,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet("foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet("foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange("bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire("foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire("foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease("bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -831,14 +829,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -849,14 +847,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -885,14 +883,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = vh.weakCompareAndSet("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -900,27 +898,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set("foo"); String o = (String) vh.getAndSet("bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set("foo"); String o = (String) vh.getAndSetAcquire("bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set("foo"); String o = (String) vh.getAndSetRelease("bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -986,7 +984,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set(array, i, "foo"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } @@ -994,21 +992,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile(array, i, "bar"); String x = (String) vh.getVolatile(array, i); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease(array, i, "foo"); String x = (String) vh.getAcquire(array, i); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque(array, i, "bar"); String x = (String) vh.getOpaque(array, i); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set(array, i, "foo"); @@ -1018,56 +1016,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet(array, i, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire(array, i, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire(array, i, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -1078,14 +1076,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -1096,14 +1094,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -1114,14 +1112,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -1132,14 +1130,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = vh.weakCompareAndSet(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -1147,27 +1145,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set(array, i, "foo"); String o = (String) vh.getAndSet(array, i, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set(array, i, "foo"); String o = (String) vh.getAndSetAcquire(array, i, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set(array, i, "foo"); String o = (String) vh.getAndSetRelease(array, i, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java index 78c13da45a9..26ac4aab893 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsChar - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsChar - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsChar */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { static final int SIZE = Character.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -158,17 +159,16 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), char.class); + assertEquals(char.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -230,7 +230,8 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -239,7 +240,6 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -740,7 +740,7 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); char x = (char) vh.get(array, i); - assertEquals(x, VALUE_1, "get char value"); + assertEquals(VALUE_1, x, "get char value"); } } } @@ -759,7 +759,7 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); char x = (char) vh.get(array, i); - assertEquals(x, VALUE_1, "get char value"); + assertEquals(VALUE_1, x, "get char value"); } if (iAligned) { @@ -767,21 +767,21 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); char x = (char) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile char value"); + assertEquals(VALUE_2, x, "setVolatile char value"); } // Lazy { vh.setRelease(array, i, VALUE_1); char x = (char) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease char value"); + assertEquals(VALUE_1, x, "setRelease char value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); char x = (char) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque char value"); + assertEquals(VALUE_2, x, "setOpaque char value"); } @@ -807,26 +807,26 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { // Plain { char x = (char) vh.get(array, i); - assertEquals(x, v, "get char value"); + assertEquals(v, x, "get char value"); } if (iAligned) { // Volatile { char x = (char) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile char value"); + assertEquals(v, x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease char value"); + assertEquals(v, x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque char value"); + assertEquals(v, x, "getOpaque char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java index 331b9073e90..a9e1e603c5d 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsDouble - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsDouble */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { static final int SIZE = Double.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -172,17 +173,16 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), double.class); + assertEquals(double.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -244,7 +244,8 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -253,7 +254,6 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -883,7 +883,7 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "get double value"); + assertEquals(VALUE_1, x, "get double value"); } } } @@ -902,7 +902,7 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "get double value"); + assertEquals(VALUE_1, x, "get double value"); } if (iAligned) { @@ -910,21 +910,21 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); double x = (double) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile double value"); + assertEquals(VALUE_2, x, "setVolatile double value"); } // Lazy { vh.setRelease(array, i, VALUE_1); double x = (double) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease double value"); + assertEquals(VALUE_1, x, "setRelease double value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); double x = (double) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque double value"); + assertEquals(VALUE_2, x, "setOpaque double value"); } vh.set(array, i, VALUE_1); @@ -934,56 +934,56 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet double value"); + assertEquals(VALUE_2, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet double value"); + assertEquals(VALUE_2, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange double value"); + assertEquals(VALUE_1, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange double value"); + assertEquals(VALUE_1, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire double value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire double value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease double value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease double value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease double value"); } { @@ -994,14 +994,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain double value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain double value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain double value"); } { @@ -1012,14 +1012,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire double"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire double value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire double value"); } { @@ -1030,14 +1030,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease double"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease double value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease double value"); } { @@ -1048,14 +1048,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet double"); + assertEquals(VALUE_1, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet double value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -1063,27 +1063,27 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet double"); + assertEquals(VALUE_1, o, "getAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet double value"); + assertEquals(VALUE_2, x, "getAndSet double value"); } { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire double"); + assertEquals(VALUE_1, o, "getAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire double value"); + assertEquals(VALUE_2, x, "getAndSetAcquire double value"); } { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease double"); + assertEquals(VALUE_1, o, "getAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease double value"); + assertEquals(VALUE_2, x, "getAndSetRelease double value"); } @@ -1109,26 +1109,26 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { // Plain { double x = (double) vh.get(array, i); - assertEquals(x, v, "get double value"); + assertEquals(v, x, "get double value"); } if (iAligned) { // Volatile { double x = (double) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile double value"); + assertEquals(v, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease double value"); + assertEquals(v, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque double value"); + assertEquals(v, x, "getOpaque double value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java index 908d61dd597..486487518e9 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsFloat - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsFloat - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsFloat */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { static final int SIZE = Float.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -172,17 +173,16 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), float.class); + assertEquals(float.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -244,7 +244,8 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -253,7 +254,6 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -883,7 +883,7 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "get float value"); + assertEquals(VALUE_1, x, "get float value"); } } } @@ -902,7 +902,7 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "get float value"); + assertEquals(VALUE_1, x, "get float value"); } if (iAligned) { @@ -910,21 +910,21 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); float x = (float) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile float value"); + assertEquals(VALUE_2, x, "setVolatile float value"); } // Lazy { vh.setRelease(array, i, VALUE_1); float x = (float) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease float value"); + assertEquals(VALUE_1, x, "setRelease float value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); float x = (float) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque float value"); + assertEquals(VALUE_2, x, "setOpaque float value"); } vh.set(array, i, VALUE_1); @@ -934,56 +934,56 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet float value"); + assertEquals(VALUE_2, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet float value"); + assertEquals(VALUE_2, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange float value"); + assertEquals(VALUE_1, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange float value"); + assertEquals(VALUE_1, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire float value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire float value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease float value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease float value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease float value"); } { @@ -994,14 +994,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain float value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain float value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain float value"); } { @@ -1012,14 +1012,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire float"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire float value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire float value"); } { @@ -1030,14 +1030,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease float"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease float value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease float value"); } { @@ -1048,14 +1048,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet float"); + assertEquals(VALUE_1, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet float value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -1063,27 +1063,27 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet float"); + assertEquals(VALUE_1, o, "getAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet float value"); + assertEquals(VALUE_2, x, "getAndSet float value"); } { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire float"); + assertEquals(VALUE_1, o, "getAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire float value"); + assertEquals(VALUE_2, x, "getAndSetAcquire float value"); } { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease float"); + assertEquals(VALUE_1, o, "getAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease float value"); + assertEquals(VALUE_2, x, "getAndSetRelease float value"); } @@ -1109,26 +1109,26 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { // Plain { float x = (float) vh.get(array, i); - assertEquals(x, v, "get float value"); + assertEquals(v, x, "get float value"); } if (iAligned) { // Volatile { float x = (float) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile float value"); + assertEquals(v, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease float value"); + assertEquals(v, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque float value"); + assertEquals(v, x, "getOpaque float value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java index 791510281c1..ce55c3d5e31 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsInt - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsInt - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsInt */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { static final int SIZE = Integer.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -190,17 +191,16 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), int.class); + assertEquals(int.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -262,7 +262,8 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -271,7 +272,6 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1039,7 +1039,7 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "get int value"); + assertEquals(VALUE_1, x, "get int value"); } } } @@ -1058,7 +1058,7 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "get int value"); + assertEquals(VALUE_1, x, "get int value"); } if (iAligned) { @@ -1066,21 +1066,21 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); int x = (int) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile int value"); + assertEquals(VALUE_2, x, "setVolatile int value"); } // Lazy { vh.setRelease(array, i, VALUE_1); int x = (int) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease int value"); + assertEquals(VALUE_1, x, "setRelease int value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); int x = (int) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque int value"); + assertEquals(VALUE_2, x, "setOpaque int value"); } vh.set(array, i, VALUE_1); @@ -1090,56 +1090,56 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet int value"); + assertEquals(VALUE_2, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet int value"); + assertEquals(VALUE_2, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange int value"); + assertEquals(VALUE_1, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange int value"); + assertEquals(VALUE_1, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire int value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire int value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease int value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease int value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease int value"); } { @@ -1150,14 +1150,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain int value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain int value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain int value"); } { @@ -1168,14 +1168,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire int"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire int value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire int value"); } { @@ -1186,14 +1186,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease int"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease int value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease int value"); } { @@ -1204,14 +1204,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet int"); + assertEquals(VALUE_1, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet int value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -1219,27 +1219,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet int"); + assertEquals(VALUE_1, o, "getAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet int value"); + assertEquals(VALUE_2, x, "getAndSet int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire int"); + assertEquals(VALUE_1, o, "getAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire int value"); + assertEquals(VALUE_2, x, "getAndSetAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease int"); + assertEquals(VALUE_1, o, "getAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease int value"); + assertEquals(VALUE_2, x, "getAndSetRelease int value"); } // get and add, add and get @@ -1247,27 +1247,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd int"); + assertEquals(VALUE_1, o, "getAndAdd int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire int"); + assertEquals(VALUE_1, o, "getAndAddAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease int"); + assertEquals(VALUE_1, o, "getAndAddRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease int value"); } // get and bitwise or @@ -1275,27 +1275,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr int"); + assertEquals(VALUE_1, o, "getAndBitwiseOr int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -1303,27 +1303,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd int"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1331,27 +1331,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor int"); + assertEquals(VALUE_1, o, "getAndBitwiseXor int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease int value"); } } } @@ -1375,26 +1375,26 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { // Plain { int x = (int) vh.get(array, i); - assertEquals(x, v, "get int value"); + assertEquals(v, x, "get int value"); } if (iAligned) { // Volatile { int x = (int) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile int value"); + assertEquals(v, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease int value"); + assertEquals(v, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque int value"); + assertEquals(v, x, "getOpaque int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java index 4188a51a559..763703b6079 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsLong - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsLong - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsLong */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { static final int SIZE = Long.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -190,17 +191,16 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), long.class); + assertEquals(long.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -262,7 +262,8 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -271,7 +272,6 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1039,7 +1039,7 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "get long value"); + assertEquals(VALUE_1, x, "get long value"); } } } @@ -1058,7 +1058,7 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "get long value"); + assertEquals(VALUE_1, x, "get long value"); } if (iAligned) { @@ -1066,21 +1066,21 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); long x = (long) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile long value"); + assertEquals(VALUE_2, x, "setVolatile long value"); } // Lazy { vh.setRelease(array, i, VALUE_1); long x = (long) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease long value"); + assertEquals(VALUE_1, x, "setRelease long value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); long x = (long) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque long value"); + assertEquals(VALUE_2, x, "setOpaque long value"); } vh.set(array, i, VALUE_1); @@ -1090,56 +1090,56 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet long value"); + assertEquals(VALUE_2, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet long value"); + assertEquals(VALUE_2, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange long value"); + assertEquals(VALUE_1, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange long value"); + assertEquals(VALUE_1, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire long value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire long value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease long value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease long value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease long value"); } { @@ -1150,14 +1150,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain long value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain long value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain long value"); } { @@ -1168,14 +1168,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire long"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire long value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire long value"); } { @@ -1186,14 +1186,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease long"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease long value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease long value"); } { @@ -1204,14 +1204,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet long"); + assertEquals(VALUE_1, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet long value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -1219,27 +1219,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet long"); + assertEquals(VALUE_1, o, "getAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet long value"); + assertEquals(VALUE_2, x, "getAndSet long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire long"); + assertEquals(VALUE_1, o, "getAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire long value"); + assertEquals(VALUE_2, x, "getAndSetAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease long"); + assertEquals(VALUE_1, o, "getAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease long value"); + assertEquals(VALUE_2, x, "getAndSetRelease long value"); } // get and add, add and get @@ -1247,27 +1247,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd long"); + assertEquals(VALUE_1, o, "getAndAdd long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire long"); + assertEquals(VALUE_1, o, "getAndAddAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease long"); + assertEquals(VALUE_1, o, "getAndAddRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease long value"); } // get and bitwise or @@ -1275,27 +1275,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr long"); + assertEquals(VALUE_1, o, "getAndBitwiseOr long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -1303,27 +1303,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd long"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1331,27 +1331,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor long"); + assertEquals(VALUE_1, o, "getAndBitwiseXor long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease long value"); } } } @@ -1375,26 +1375,26 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { // Plain { long x = (long) vh.get(array, i); - assertEquals(x, v, "get long value"); + assertEquals(v, x, "get long value"); } if (iAligned) { // Volatile { long x = (long) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile long value"); + assertEquals(v, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease long value"); + assertEquals(v, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque long value"); + assertEquals(v, x, "getOpaque long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java index 1ecfef0476e..7a3bc069c22 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsShort - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsShort - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsShort */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { static final int SIZE = Short.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -158,17 +159,16 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), short.class); + assertEquals(short.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -230,7 +230,8 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -239,7 +240,6 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -740,7 +740,7 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); short x = (short) vh.get(array, i); - assertEquals(x, VALUE_1, "get short value"); + assertEquals(VALUE_1, x, "get short value"); } } } @@ -759,7 +759,7 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); short x = (short) vh.get(array, i); - assertEquals(x, VALUE_1, "get short value"); + assertEquals(VALUE_1, x, "get short value"); } if (iAligned) { @@ -767,21 +767,21 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); short x = (short) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile short value"); + assertEquals(VALUE_2, x, "setVolatile short value"); } // Lazy { vh.setRelease(array, i, VALUE_1); short x = (short) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease short value"); + assertEquals(VALUE_1, x, "setRelease short value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); short x = (short) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque short value"); + assertEquals(VALUE_2, x, "setOpaque short value"); } @@ -807,26 +807,26 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { // Plain { short x = (short) vh.get(array, i); - assertEquals(x, v, "get short value"); + assertEquals(v, x, "get short value"); } if (iAligned) { // Volatile { short x = (short) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile short value"); + assertEquals(v, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease short value"); + assertEquals(v, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque short value"); + assertEquals(v, x, "getOpaque short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java index fc706815bce..9960e08a0c7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -26,20 +26,20 @@ * @modules java.base/jdk.internal.access.foreign * @modules java.base/jdk.internal.foreign.layout * - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true @@ -50,9 +50,6 @@ import java.lang.foreign.Arena; import java.lang.foreign.MemorySegment; import jdk.internal.foreign.layout.ValueLayouts; -import org.testng.SkipException; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; @@ -64,8 +61,13 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestExact { private static class Widget { @@ -90,12 +92,13 @@ public class VarHandleTestExact { final Long aLongField_RO = 1234L; } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactSet(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) throws NoSuchFieldException, IllegalAccessException { - if (ro) throw new SkipException("Can not test setter with read only field"); + Assumptions.assumeFalse(ro, "Can not test setter with read only field"); VarHandle vh = MethodHandles.lookup().findVarHandle(Widget.class, fieldBaseName + "_RW", fieldType); Widget w = new Widget(); @@ -105,7 +108,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (Widget," + fieldType.getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactGet(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) @@ -119,12 +123,13 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (Widget)" + fieldType.getSimpleName() + " \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactSetStatic(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) throws NoSuchFieldException, IllegalAccessException { - if (ro) throw new SkipException("Can not test setter with read only field"); + Assumptions.assumeFalse(ro, "Can not test setter with read only field"); VarHandle vh = MethodHandles.lookup().findStaticVarHandle(Widget.class, fieldBaseName + "_SRW", fieldType); doTest(vh, @@ -133,7 +138,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (" + fieldType.getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactGetStatic(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) @@ -146,7 +152,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type ()" + fieldType.getSimpleName() + " \\E.*"); } - @Test(dataProvider = "dataSetArray") + @ParameterizedTest + @MethodSource("dataSetArray") public void testExactArraySet(Class arrayClass, Object testValue, SetArrayX setter) { VarHandle vh = MethodHandles.arrayElementVarHandle(arrayClass); Object arr = Array.newInstance(arrayClass.componentType(), 1); @@ -157,7 +164,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (" + arrayClass.getSimpleName() + ",int," + arrayClass.componentType().getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataSetBuffer") + @ParameterizedTest + @MethodSource("dataSetBuffer") public void testExactBufferSet(Class arrayClass, Object testValue, SetBufferX setter) { VarHandle vh = MethodHandles.byteBufferViewVarHandle(arrayClass, ByteOrder.nativeOrder()); ByteBuffer buff = ByteBuffer.allocateDirect(8); @@ -168,7 +176,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (ByteBuffer,int," + arrayClass.componentType().getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataSetMemorySegment") + @ParameterizedTest + @MethodSource("dataSetMemorySegment") public void testExactSegmentSet(Class carrier, Object testValue, SetSegmentX setter) { VarHandle vh = ValueLayouts.valueLayout(carrier, ByteOrder.nativeOrder()).varHandle(); try (Arena arena = Arena.ofConfined()) { @@ -265,7 +274,6 @@ public class VarHandleTestExact { cases.add(new Object[] { carrier, testValue, setter }); } - @DataProvider public static Object[][] dataObjectAccess() { List cases = new ArrayList<>(); @@ -334,7 +342,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetArray() { List cases = new ArrayList<>(); @@ -355,7 +362,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetBuffer() { List cases = new ArrayList<>(); @@ -373,7 +379,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetMemorySegment() { List cases = new ArrayList<>(); diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java index 14d5c05d3b8..6540693a906 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessBoolean.class, "final_v", boolean.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessBoolean recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(recv, true); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get { boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } @@ -300,27 +298,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -328,27 +326,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -356,27 +354,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -404,21 +402,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(true); @@ -428,56 +426,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -489,14 +487,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -508,7 +506,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { @@ -516,7 +514,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -528,14 +526,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -547,14 +545,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing weakCompareAndSetRe boolean value"); + assertEquals(true, x, "failing weakCompareAndSetRe boolean value"); } // Compare set and get @@ -562,9 +560,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } // Compare set and get @@ -572,9 +570,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } // Compare set and get @@ -582,9 +580,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -593,27 +591,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -621,27 +619,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -649,27 +647,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -692,7 +690,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } @@ -700,21 +698,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, true); @@ -724,56 +722,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -785,14 +783,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -804,14 +802,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -823,14 +821,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(false, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -842,14 +840,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -857,27 +855,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -886,27 +884,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -914,27 +912,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -942,27 +940,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java index 5b3eafba63b..6f7f54a57f5 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessByte.class, "final_v", byte.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessByte recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get { byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact((byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact((byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact((byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact((byte)0x01); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetRe byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetRe byte value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java index d191b507366..3e31ee282ff 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessChar.class, "final_v", char.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessChar recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, '\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get { char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact('\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact('\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact('\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact('\u0123'); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing weakCompareAndSetRe char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetRe char value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, '\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetAcquire char value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java index fe0455d2375..056d45478ed 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessDouble.class, "final_v", double.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessDouble recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get { double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -340,7 +338,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -348,21 +346,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(1.0d); @@ -372,56 +370,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -433,14 +431,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -452,7 +450,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { @@ -460,7 +458,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -472,14 +470,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -491,14 +489,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing weakCompareAndSetRe double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetRe double value"); } // Compare set and get @@ -506,9 +504,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } // Compare set and get @@ -516,9 +514,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } // Compare set and get @@ -526,9 +524,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -536,27 +534,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -580,7 +578,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } @@ -588,21 +586,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); @@ -612,56 +610,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -673,14 +671,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -692,14 +690,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -711,14 +709,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -745,27 +743,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -773,27 +771,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java index 256e4723eec..98eb72301cb 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessFloat.class, "final_v", float.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessFloat recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get { float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -340,7 +338,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -348,21 +346,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(1.0f); @@ -372,56 +370,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -433,14 +431,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -452,7 +450,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { @@ -460,7 +458,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -472,14 +470,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -491,14 +489,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing weakCompareAndSetRe float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetRe float value"); } // Compare set and get @@ -506,9 +504,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } // Compare set and get @@ -516,9 +514,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } // Compare set and get @@ -526,9 +524,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -536,27 +534,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -580,7 +578,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } @@ -588,21 +586,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); @@ -612,56 +610,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -673,14 +671,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -692,14 +690,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -711,14 +709,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -745,27 +743,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -773,27 +771,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java index d8558e0b070..920d8453bab 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessInt.class, "final_v", int.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessInt recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get { int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(0x01234567); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetRe int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetRe int value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetAcquire int value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java index 0e73063395d..90f6dd12c47 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessLong.class, "final_v", long.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get { long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetRe long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetRe long value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java index 8fb23d7dc55..d8f548fe2d6 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessShort.class, "final_v", short.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessShort recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get { short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact((short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact((short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact((short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact((short)0x0123); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetRe short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetRe short value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetAcquire short value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java index 8ccede760c9..35723f63d27 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessString.class, "final_v", String.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(String[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, "bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, "foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, "bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get { String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } @@ -318,7 +316,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact("foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -326,21 +324,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact("bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact("foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact("bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact("foo"); @@ -350,56 +348,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -411,14 +409,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -430,7 +428,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { @@ -438,7 +436,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -450,14 +448,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -469,14 +467,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing weakCompareAndSetRe String value"); + assertEquals("foo", x, "failing weakCompareAndSetRe String value"); } // Compare set and get @@ -484,9 +482,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact("bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } // Compare set and get @@ -494,9 +492,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact("bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } // Compare set and get @@ -504,9 +502,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact("bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -536,7 +534,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } @@ -544,21 +542,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, "bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, "foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, "bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); @@ -568,56 +566,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -629,14 +627,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -648,14 +646,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -667,14 +665,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetAcquire String value"); + assertEquals("bar", x, "failing weakCompareAndSetAcquire String value"); } { @@ -686,14 +684,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -701,27 +699,27 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java index eb6327d4c55..b10466a1fc7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean + * @run junit/othervm VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeBoolean.class, "final_v", boolean.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java index 08b834699af..ce8686ebd74 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte + * @run junit/othervm VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeByte.class, "final_v", byte.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeByte recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java index 25aa62825b7..d89af7f212c 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar + * @run junit/othervm VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeChar.class, "final_v", char.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeChar recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java index c3f8d22435b..0363a996ceb 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble + * @run junit/othervm VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeDouble.class, "final_v", double.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeDouble recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java index 0d05270b3ac..c8b965e41df 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat + * @run junit/othervm VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeFloat.class, "final_v", float.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeFloat recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java index a431c0a889e..e09427c55c7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt + * @run junit/othervm VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeInt.class, "final_v", int.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeInt recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java index 53b9257d700..5944e935877 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong + * @run junit/othervm VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeLong.class, "final_v", long.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeLong recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java index 10dd5832c9b..fdb30ee88aa 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort + * @run junit/othervm VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeShort.class, "final_v", short.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeShort recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java index d823a21d69f..2a5284ca36e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString + * @run junit/othervm VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeString.class, "final_v", String.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(String[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeString recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java index b20e18d263e..2c22fd5595b 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2026, 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 @@ -23,11 +23,9 @@ /* * @test - * @run testng VarHandleTestReflection + * @run junit VarHandleTestReflection */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandleInfo; @@ -36,11 +34,16 @@ import java.lang.invoke.VarHandle; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.stream.Stream; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestReflection extends VarHandleBaseTest { String string; - @DataProvider public static Object[][] accessModesProvider() { return Stream.of(VarHandle.AccessMode.values()). map(am -> new Object[]{am}). @@ -52,17 +55,19 @@ public class VarHandleTestReflection extends VarHandleBaseTest { findVarHandle(VarHandleTestReflection.class, "string", String.class); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationArgumentMismatch(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); // Try a reflective invoke using a Method, with no arguments Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class); - vhm.invoke(v, new Object[]{}); + assertThrows(IllegalArgumentException.class, () -> vhm.invoke(v, new Object[]{})); } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationMatchingArguments(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -70,17 +75,15 @@ public class VarHandleTestReflection extends VarHandleBaseTest { Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class); Object arg = new Object[0]; - try { - vhm.invoke(v, arg); - } catch (InvocationTargetException e) { - if (!(e.getCause() instanceof UnsupportedOperationException)) { - throw new RuntimeException("expected UnsupportedOperationException but got: " - + e.getCause().getClass().getName(), e); - } + var e = assertThrows(InvocationTargetException.class, () -> vhm.invoke(v, arg)); + if (!(e.getCause() instanceof UnsupportedOperationException)) { + throw new RuntimeException("expected UnsupportedOperationException but got: " + + e.getCause().getClass().getName(), e); } } - @Test(dataProvider = "accessModesProvider", expectedExceptions = UnsupportedOperationException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodHandleInvoke(VarHandle.AccessMode accessMode) throws Throwable { VarHandle v = handle(); @@ -90,10 +93,13 @@ public class VarHandleTestReflection extends VarHandleBaseTest { VarHandle.class.getMethod(accessMode.methodName(), Object[].class)); // Use invoke to avoid WrongMethodTypeException for // non-signature-polymorphic return types - Object o = (Object) mh.invoke(v, new Object[]{}); + assertThrows(UnsupportedOperationException.class, () -> { + Object o = (Object) mh.invoke(v, new Object[]{}); + }); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationFromMethodInfo(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -104,10 +110,13 @@ public class VarHandleTestReflection extends VarHandleBaseTest { VarHandle.class.getMethod(accessMode.methodName(), Object[].class)); MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); Method im = info.reflectAs(Method.class, MethodHandles.lookup()); - im.invoke(v, new Object[]{}); + assertThrows(IllegalArgumentException.class, () -> { + im.invoke(v, new Object[]{}); + }); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void reflectAsFromVarHandleInvoker(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -116,10 +125,11 @@ public class VarHandleTestReflection extends VarHandleBaseTest { MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - info.reflectAs(Method.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup())); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void reflectAsFromFindVirtual(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -128,6 +138,6 @@ public class VarHandleTestReflection extends VarHandleBaseTest { MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - info.reflectAs(Method.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup())); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template index f3c90c5e8cc..b18dbb6e1b0 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccess$Type$ * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$ - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccess$Type$ - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccess$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -115,7 +117,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccess$Type$.class, "final_v", $type$.class); @@ -135,8 +137,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { #end[String] } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -166,7 +166,8 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -236,8 +237,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { #end[Bitwise] } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccess$Type$.class)}); @@ -247,16 +246,16 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), $type$.class); + assertEquals($type$.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -283,8 +282,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -335,7 +332,8 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -348,26 +346,26 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { // Plain { $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } // Volatile { $type$ x = ($type$) vh.getVolatile(recv); - assertEquals(x, $value1$, "getVolatile $type$ value"); + assertEquals($value1$, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(recv); - assertEquals(x, $value1$, "getRelease $type$ value"); + assertEquals($value1$, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(recv); - assertEquals(x, $value1$, "getOpaque $type$ value"); + assertEquals($value1$, x, "getOpaque $type$ value"); } } @@ -492,26 +490,26 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { // Plain { $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } // Volatile { $type$ x = ($type$) vh.getVolatile(); - assertEquals(x, $value1$, "getVolatile $type$ value"); + assertEquals($value1$, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(); - assertEquals(x, $value1$, "getRelease $type$ value"); + assertEquals($value1$, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(); - assertEquals(x, $value1$, "getOpaque $type$ value"); + assertEquals($value1$, x, "getOpaque $type$ value"); } } @@ -637,7 +635,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set(recv, $value1$); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -645,21 +643,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile(recv, $value2$); $type$ x = ($type$) vh.getVolatile(recv); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(recv, $value1$); $type$ x = ($type$) vh.getAcquire(recv); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(recv, $value2$); $type$ x = ($type$) vh.getOpaque(recv); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -670,56 +668,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(recv, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -748,14 +746,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -766,14 +764,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -784,14 +782,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "success weakCompareAndSet $type$ value"); } { boolean success = vh.weakCompareAndSet(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -799,27 +797,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSet(recv, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSetAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSetRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -829,27 +827,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAdd(recv, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAddAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAddRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -859,27 +857,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOr(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -887,27 +885,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAnd(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -915,27 +913,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXor(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1046,7 +1044,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set($value1$); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -1054,21 +1052,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile($value2$); $type$ x = ($type$) vh.getVolatile(); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease($value1$); $type$ x = ($type$) vh.getAcquire(); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque($value2$); $type$ x = ($type$) vh.getOpaque(); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -1079,56 +1077,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet($value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet($value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1139,14 +1137,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1157,14 +1155,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1175,14 +1173,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1193,14 +1191,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1208,27 +1206,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndSet($value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndSetAcquire($value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndSetRelease($value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1238,27 +1236,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndAdd($value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndAddAcquire($value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndAddRelease($value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1268,27 +1266,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOr($value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1296,27 +1294,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAnd($value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1324,27 +1322,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXor($value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1458,7 +1456,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set(array, i, $value1$); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } @@ -1466,21 +1464,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile(array, i, $value2$); $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(array, i, $value1$); $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(array, i, $value2$); $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -1491,56 +1489,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(array, i, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1551,14 +1549,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1569,14 +1567,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1587,14 +1585,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1605,14 +1603,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1620,27 +1618,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSet(array, i, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSetAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSetRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1650,27 +1648,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAdd(array, i, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAddAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAddRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1680,27 +1678,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOr(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1708,27 +1706,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1736,27 +1734,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXor(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template index c21709d6d37..9a40bfb2780 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$ - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAs$Type$ - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAs$Type$ */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { static final int SIZE = $BoxType$.BYTES; @@ -111,7 +111,8 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -206,17 +207,16 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { #end[Bitwise] } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), $type$.class); + assertEquals($type$.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -278,7 +278,8 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -287,7 +288,6 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1272,7 +1272,7 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "get $type$ value"); + assertEquals(VALUE_1, x, "get $type$ value"); } } } @@ -1291,7 +1291,7 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "get $type$ value"); + assertEquals(VALUE_1, x, "get $type$ value"); } if (iAligned) { @@ -1299,21 +1299,21 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile $type$ value"); + assertEquals(VALUE_2, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(array, i, VALUE_1); $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease $type$ value"); + assertEquals(VALUE_1, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque $type$ value"); + assertEquals(VALUE_2, x, "setOpaque $type$ value"); } #if[CAS] @@ -1324,56 +1324,56 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet $type$ value"); + assertEquals(VALUE_2, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet $type$ value"); + assertEquals(VALUE_2, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange $type$ value"); + assertEquals(VALUE_1, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange $type$ value"); + assertEquals(VALUE_1, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire $type$ value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire $type$ value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease $type$ value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease $type$ value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1384,14 +1384,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain $type$ value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain $type$ value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1402,14 +1402,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire $type$"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1420,14 +1420,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease $type$"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease $type$ value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1438,14 +1438,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet $type$"); + assertEquals(VALUE_1, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet $type$ value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1453,27 +1453,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet $type$"); + assertEquals(VALUE_1, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet $type$ value"); + assertEquals(VALUE_2, x, "getAndSet $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire $type$"); + assertEquals(VALUE_1, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire $type$ value"); + assertEquals(VALUE_2, x, "getAndSetAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease $type$"); + assertEquals(VALUE_1, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease $type$ value"); + assertEquals(VALUE_2, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1483,27 +1483,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd $type$"); + assertEquals(VALUE_1, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire $type$"); + assertEquals(VALUE_1, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease $type$"); + assertEquals(VALUE_1, o, "getAndAddRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1513,27 +1513,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1541,27 +1541,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1569,27 +1569,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1614,26 +1614,26 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { // Plain { $type$ x = ($type$) vh.get(array, i); - assertEquals(x, v, "get $type$ value"); + assertEquals(v, x, "get $type$ value"); } if (iAligned) { // Volatile { $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile $type$ value"); + assertEquals(v, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease $type$ value"); + assertEquals(v, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque $type$ value"); + assertEquals(v, x, "getOpaque $type$ value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template index 4a9fa7c4fe8..a347b232d7e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccess$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccess$Type$.class, "final_v", $type$.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle($type$[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccess$Type$ recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -159,56 +157,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -220,14 +218,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -239,14 +237,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -258,14 +256,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -277,22 +275,22 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get { $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } #end[CAS] @@ -302,27 +300,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -332,27 +330,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -360,27 +358,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -388,27 +386,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -457,7 +455,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -465,21 +463,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact($value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact($value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact($value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -490,56 +488,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -551,14 +549,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -570,7 +568,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { @@ -578,7 +576,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -590,14 +588,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -609,14 +607,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing weakCompareAndSetRe $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetRe $type$ value"); } // Compare set and get @@ -624,9 +622,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } // Compare set and get @@ -634,9 +632,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } // Compare set and get @@ -644,9 +642,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -656,27 +654,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -686,27 +684,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -714,27 +712,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -742,27 +740,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -814,7 +812,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } @@ -822,21 +820,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -847,56 +845,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -908,14 +906,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -927,14 +925,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -946,14 +944,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -965,14 +963,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -980,27 +978,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1010,27 +1008,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1040,27 +1038,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1068,27 +1066,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1096,27 +1094,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template index 85ecf9bb95c..77531cc309f 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ + * @run junit/othervm VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -63,7 +63,7 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodType$Type$.class, "final_v", $type$.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle($type$[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodType$Type$ recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java b/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java index 343b15a1caf..11cd6ec233c 100644 --- a/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java +++ b/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -27,14 +27,11 @@ * @compile TestFieldLookupAccessibility.java * pkg/A.java pkg/B_extends_A.java pkg/C.java * pkg/subpkg/B_extends_A.java pkg/subpkg/C.java - * @run testng/othervm --enable-final-field-mutation=ALL-UNNAMED -DwriteAccess=true TestFieldLookupAccessibility - * @run testng/othervm --illegal-final-field-mutation=deny -DwriteAccess=false TestFieldLookupAccessibility + * @run junit/othervm --enable-final-field-mutation=ALL-UNNAMED -DwriteAccess=true TestFieldLookupAccessibility + * @run junit/othervm --illegal-final-field-mutation=deny -DwriteAccess=false TestFieldLookupAccessibility */ -import static org.testng.Assert.*; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; +import static org.junit.jupiter.api.Assertions.*; import pkg.B_extends_A; import java.lang.invoke.MethodHandles; @@ -48,11 +45,14 @@ import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestFieldLookupAccessibility { static boolean writeAccess; - @BeforeClass + @BeforeAll static void setup() { String s = System.getProperty("writeAccess"); assertNotNull(s); @@ -188,8 +188,7 @@ public class TestFieldLookupAccessibility { } } - @DataProvider - public Object[][] lookupProvider() throws Exception { + public static Object[][] lookupProvider() throws Exception { Stream> baseCases = Stream.of( // Look up from same package List.of(pkg.A.class, pkg.A.lookup(), pkg.A.inaccessibleFields()), @@ -215,7 +214,8 @@ public class TestFieldLookupAccessibility { return pl.toArray(); } - @Test(dataProvider = "lookupProvider") + @ParameterizedTest + @MethodSource("lookupProvider") public void test(FieldLookup fl, Class src, MethodHandles.Lookup l, Set inaccessibleFields) { // Add to the expected failures all inaccessible fields due to accessibility modifiers Set expected = fl.inaccessibleFields(inaccessibleFields); @@ -240,10 +240,10 @@ public class TestFieldLookupAccessibility { collect(Collectors.toSet()); if (!actualFieldNames.equals(expected)) { if (actualFieldNames.isEmpty()) { - assertEquals(actualFieldNames, expected, "No accessibility failures:"); + assertEquals(expected, actualFieldNames, "No accessibility failures:"); } else { - assertEquals(actualFieldNames, expected, "Accessibility failures differ:"); + assertEquals(expected, actualFieldNames, "Accessibility failures differ:"); } } else { diff --git a/test/jdk/java/lang/invoke/WrongMethodTypeTest.java b/test/jdk/java/lang/invoke/WrongMethodTypeTest.java index be0c59e0d77..32cbfc545ce 100644 --- a/test/jdk/java/lang/invoke/WrongMethodTypeTest.java +++ b/test/jdk/java/lang/invoke/WrongMethodTypeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, 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 @@ -21,8 +21,9 @@ * questions. */ -/* @test 8299183 - * @run testng WrongMethodTypeTest +/* @test + * @bug 8299183 + * @run junit WrongMethodTypeTest */ import java.lang.invoke.MethodHandle; @@ -33,9 +34,10 @@ import java.lang.invoke.WrongMethodTypeException; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class WrongMethodTypeTest { static final Lookup LOOKUP = MethodHandles.lookup(); @@ -43,13 +45,11 @@ public class WrongMethodTypeTest { @Test public void checkExactType() throws Throwable { String expectedMessage = "handle's method type (int)int but found ()boolean"; - try { - MethodHandle mh = LOOKUP.findStatic(WrongMethodTypeTest.class, "m", methodType(int.class, int.class)); + MethodHandle mh = LOOKUP.findStatic(WrongMethodTypeTest.class, "m", methodType(int.class, int.class)); + var ex = assertThrows(WrongMethodTypeException.class, () -> { boolean b = (boolean)mh.invokeExact(); - fail("Expected WrongMethodTypeException"); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } @Test @@ -57,11 +57,10 @@ public class WrongMethodTypeTest { String expectedMessage = "handle's method type ()int but found ()Void"; VarHandle vh = LOOKUP.findStaticVarHandle(WrongMethodTypeTest.class, "x", int.class) .withInvokeExactBehavior(); - try { + var ex = assertThrows(WrongMethodTypeException.class, () -> { Void o = (Void) vh.get(); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } @Test @@ -69,11 +68,10 @@ public class WrongMethodTypeTest { String expectedMessage = "handle's method type (WrongMethodTypeTest)boolean but found (WrongMethodTypeTest)int"; VarHandle vh = LOOKUP.findVarHandle(WrongMethodTypeTest.class, "y", boolean.class) .withInvokeExactBehavior(); - try { + var ex = assertThrows(WrongMethodTypeException.class, () -> { int o = (int) vh.get(new WrongMethodTypeTest()); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } static int m(int x) { diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java index 083a357a430..23893655c0a 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @bug 8150782 8207027 8266269 * @compile TestAccessClass.java TestCls.java p/Foo.java q/Bar.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestAccessClass + * @run junit/othervm -ea -esa test.java.lang.invoke.TestAccessClass */ package test.java.lang.invoke; @@ -36,9 +36,11 @@ import q.Bar; import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; public class TestAccessClass { @@ -68,17 +70,19 @@ public class TestAccessClass { assertEquals(Class1[].class, aClass); } - @DataProvider - Object[][] illegalAccessAccess() { + static Object[][] illegalAccessAccess() { return new Object[][] { {publicLookup(), Class1.class}, {publicLookup(), TestCls.getPrivateSIC()} }; } - @Test(dataProvider = "illegalAccessAccess", expectedExceptions = {IllegalAccessException.class}) + @ParameterizedTest + @MethodSource("illegalAccessAccess") public void illegalAccessExceptionTest(Lookup lookup, Class klass) throws IllegalAccessException { - lookup.accessClass(klass); + assertThrows(IllegalAccessException.class, () -> { + lookup.accessClass(klass); + }); } @Test @@ -98,8 +102,8 @@ public class TestAccessClass { mh.invoke(null); } - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void illegalArgument() throws IllegalAccessException { - lookup().accessClass(null); + assertThrows(NullPointerException.class, () -> lookup().accessClass(null)); } } diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java index 54674729fe3..94ec3c54b4f 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @bug 8150782 8207027 8266269 * @compile TestFindClass.java TestCls.java p/Foo.java q/Bar.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestFindClass + * @run junit/othervm -ea -esa test.java.lang.invoke.TestFindClass */ package test.java.lang.invoke; @@ -34,9 +34,11 @@ import q.Bar; import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; public class TestFindClass { @@ -68,13 +70,12 @@ public class TestFindClass { assertEquals(Class1[].class, aClass); } - @Test(expectedExceptions = {ClassNotFoundException.class}) + @Test public void classNotFoundExceptionTest() throws IllegalAccessException, ClassNotFoundException { - lookup().findClass(PACKAGE_PREFIX + "TestFindClass$NonExistent"); + assertThrows(ClassNotFoundException.class, () -> lookup().findClass(PACKAGE_PREFIX + "TestFindClass$NonExistent")); } - @DataProvider - Object[][] illegalAccessFind() { + static Object[][] illegalAccessFind() { return new Object[][] { {publicLookup(), PACKAGE_PREFIX + "TestFindClass$Class1"}, {publicLookup(), PACKAGE_PREFIX + "TestCls$PrivateSIC"} @@ -84,9 +85,10 @@ public class TestFindClass { /** * Assertion: @throws IllegalAccessException if the class is not accessible, using the allowed access modes. */ - @Test(dataProvider = "illegalAccessFind", expectedExceptions = {ClassNotFoundException.class}) + @ParameterizedTest + @MethodSource("illegalAccessFind") public void illegalAccessExceptionTest(Lookup lookup, String className) throws IllegalAccessException, ClassNotFoundException { - lookup.findClass(className); + assertThrows(ClassNotFoundException.class, () -> lookup.findClass(className)); } @Test @@ -104,8 +106,8 @@ public class TestFindClass { lookup().findClass("[Lp.Foo$T;"); } - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void illegalArgument() throws IllegalAccessException, ClassNotFoundException { - lookup().findClass(null); + assertThrows(NullPointerException.class, () -> lookup().findClass(null)); } } diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java index 555213bedcc..b0f2e00adbc 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -23,15 +23,15 @@ /* @test * @compile TestLookup.java TestCls.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestLookup + * @run junit/othervm -ea -esa test.java.lang.invoke.TestLookup */ package test.java.lang.invoke; -import org.testng.annotations.Test; - import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class TestLookup { @@ -43,10 +43,10 @@ public class TestLookup { assertNull(lookup2.lookupClass().getClassLoader()); } - @Test(expectedExceptions = {ClassNotFoundException.class}) + @Test public void testPublicCannotLoadUserClass() throws IllegalAccessException, ClassNotFoundException { Lookup lookup = publicLookup(); - lookup.findClass("test.java.lang.invoke.TestCls"); + assertThrows(ClassNotFoundException.class, () -> lookup.findClass("test.java.lang.invoke.TestCls")); } @Test diff --git a/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java b/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java index a6359162629..67aa90ba99c 100644 --- a/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java +++ b/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, 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 @@ -24,7 +24,7 @@ /* @test * @bug 8196830 8235351 8257874 * @modules java.base/jdk.internal.reflect - * @run testng/othervm CallerSensitiveAccess + * @run junit/othervm CallerSensitiveAccess * @summary Check Lookup findVirtual, findStatic and unreflect behavior with * caller sensitive methods with focus on AccessibleObject.setAccessible */ @@ -50,17 +50,16 @@ import java.util.stream.Stream; import jdk.internal.reflect.CallerSensitive; -import org.testng.annotations.DataProvider; -import org.testng.annotations.NoInjection; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class CallerSensitiveAccess { /** * Caller sensitive methods in APIs exported by java.base. */ - @DataProvider(name = "callerSensitiveMethods") static Object[][] callerSensitiveMethods() { try (Stream stream = callerSensitiveMethods(Object.class.getModule())) { return stream.map(m -> new Object[]{m, shortDescription(m)}) @@ -72,34 +71,35 @@ public class CallerSensitiveAccess { * Using publicLookup, attempt to use findVirtual or findStatic to obtain a * method handle to a caller sensitive method. */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testPublicLookupFind(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testPublicLookupFind(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.publicLookup(); Class refc = method.getDeclaringClass(); String name = method.getName(); MethodType mt = MethodType.methodType(method.getReturnType(), method.getParameterTypes()); - if (Modifier.isStatic(method.getModifiers())) { - lookup.findStatic(refc, name, mt); - } else { - lookup.findVirtual(refc, name, mt); - } + assertThrows(IllegalAccessException.class, () -> { + if (Modifier.isStatic(method.getModifiers())) { + lookup.findStatic(refc, name, mt); + } else { + lookup.findVirtual(refc, name, mt); + } + }); } /** * Using publicLookup, attempt to use unreflect to obtain a method handle to a * caller sensitive method. */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testPublicLookupUnreflect(@NoInjection Method method, String desc) throws Exception { - MethodHandles.publicLookup().unreflect(method); + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testPublicLookupUnreflect(Method method, String desc) throws Exception { + assertThrows(IllegalAccessException.class, () -> MethodHandles.publicLookup().unreflect(method)); } /** * public accessible caller sensitive methods in APIs exported by java.base. */ - @DataProvider(name = "accessibleCallerSensitiveMethods") static Object[][] accessibleCallerSensitiveMethods() { try (Stream stream = callerSensitiveMethods(Object.class.getModule())) { return stream @@ -114,41 +114,43 @@ public class CallerSensitiveAccess { * Using publicLookup, attempt to use unreflect to obtain a method handle to a * caller sensitive method. */ - @Test(dataProvider = "accessibleCallerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupUnreflect(@NoInjection Method method, String desc) throws Exception { - MethodHandles.publicLookup().unreflect(method); + @ParameterizedTest + @MethodSource("accessibleCallerSensitiveMethods") + public void testLookupUnreflect(Method method, String desc) throws Exception { + assertThrows(IllegalAccessException.class, () -> MethodHandles.publicLookup().unreflect(method)); } /** * Using a Lookup with no original access that can't lookup caller-sensitive * method */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupNoOriginalAccessFind(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testLookupNoOriginalAccessFind(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.ORIGINAL); assertTrue(lookup.hasFullPrivilegeAccess()); Class refc = method.getDeclaringClass(); String name = method.getName(); MethodType mt = MethodType.methodType(method.getReturnType(), method.getParameterTypes()); - if (Modifier.isStatic(method.getModifiers())) { - lookup.findStatic(refc, name, mt); - } else { - lookup.findVirtual(refc, name, mt); - } + assertThrows(IllegalAccessException.class, () -> { + if (Modifier.isStatic(method.getModifiers())) { + lookup.findStatic(refc, name, mt); + } else { + lookup.findVirtual(refc, name, mt); + } + }); } /** * Using a Lookup with no original access that can't unreflect caller-sensitive * method */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupNoOriginalAccessUnreflect(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testLookupNoOriginalAccessUnreflect(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.ORIGINAL); assertTrue(lookup.hasFullPrivilegeAccess()); - lookup.unreflect(method); + assertThrows(IllegalAccessException.class, () -> lookup.unreflect(method)); } // -- Test method handles to setAccessible -- @@ -156,21 +158,12 @@ public class CallerSensitiveAccess { private int aField; Field accessibleField() { - try { - return getClass().getDeclaredField("aField"); - } catch (NoSuchFieldException e) { - fail(); - return null; - } + var clazz = getClass(); + return assertDoesNotThrow(() -> clazz.getDeclaredField("aField")); } Field inaccessibleField() { - try { - return String.class.getDeclaredField("hash"); - } catch (NoSuchFieldException e) { - fail(); - return null; - } + return assertDoesNotThrow(() -> String.class.getDeclaredField("hash")); } void findAndInvokeSetAccessible(Class refc, Field f) throws Throwable { @@ -215,23 +208,23 @@ public class CallerSensitiveAccess { * Create a method handle to setAccessible and attempt to use it to suppress * access to an inaccessible member. */ - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible5() throws Throwable { - findAndInvokeSetAccessible(AccessibleObject.class, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> findAndInvokeSetAccessible(AccessibleObject.class, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible6() throws Throwable { - findAndInvokeSetAccessible(Field.class, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> findAndInvokeSetAccessible(Field.class, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible7() throws Throwable { Method m = AccessibleObject.class.getMethod("setAccessible", boolean.class); - unreflectAndInvokeSetAccessible(m, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> unreflectAndInvokeSetAccessible(m, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible8() throws Throwable { Method m = Field.class.getMethod("setAccessible", boolean.class); - unreflectAndInvokeSetAccessible(m, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> unreflectAndInvokeSetAccessible(m, inaccessibleField())); } @@ -241,7 +234,6 @@ public class CallerSensitiveAccess { * Custom AccessibleObject objects. One class overrides setAccessible, the other * does not override this method. */ - @DataProvider(name = "customAccessibleObjects") static Object[][] customAccessibleObjectClasses() { return new Object[][] { { new S1() }, { new S2() } }; } @@ -271,20 +263,20 @@ public class CallerSensitiveAccess { * Using publicLookup, create a method handle to setAccessible and invoke it * on a custom AccessibleObject object. */ - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void testPublicLookupSubclass1() throws Throwable { // S1 does not override setAccessible - findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1()); + assertThrows(IllegalAccessException.class, () -> findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1())); } @Test public void testPublicLookupSubclass2() throws Throwable { // S2 overrides setAccessible findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S2()); } - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void testPublicLookupSubclass3() throws Throwable { // S1 does not override setAccessible - unreflectAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1()); + assertThrows(IllegalAccessException.class, () -> unreflectAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1())); } @Test public void testPublicLookupSubclass4() throws Throwable { @@ -296,11 +288,13 @@ public class CallerSensitiveAccess { * Using a full power lookup, create a method handle to setAccessible and * invoke it on a custom AccessibleObject object. */ - @Test(dataProvider = "customAccessibleObjects") + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass1(AccessibleObject obj) throws Throwable { findAndInvokeSetAccessible(MethodHandles.lookup(), obj); } - @Test(dataProvider = "customAccessibleObjects") + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass2(AccessibleObject obj) throws Throwable { unreflectAndInvokeSetAccessible(MethodHandles.lookup(), obj); } @@ -309,13 +303,13 @@ public class CallerSensitiveAccess { * Using a full power lookup, create a method handle to setAccessible on a * sub-class of AccessibleObject and then attempt to invoke it on a Field object. */ - @Test(dataProvider = "customAccessibleObjects", - expectedExceptions = ClassCastException.class) + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass3(AccessibleObject obj) throws Throwable { MethodType mt = MethodType.methodType(void.class, boolean.class); Lookup lookup = MethodHandles.lookup(); MethodHandle mh = lookup.findVirtual(obj.getClass(), "setAccessible", mt); - mh.invoke(accessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(accessibleField(), true)); } /** @@ -333,29 +327,29 @@ public class CallerSensitiveAccess { mh.invoke(f, true); assertTrue(f.isAccessible()); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testLookupSubclass5() throws Throwable { // S1 does not override setAccessible Method m = S1.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == AccessibleObject.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(inaccessibleField(), true); // should throw InaccessibleObjectException + assertThrows(InaccessibleObjectException.class, () -> mh.invoke(inaccessibleField(), true)); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testLookupSubclass6() throws Throwable { // S2 overrides setAccessible Method m = S2.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == S2.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(accessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(accessibleField(), true)); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testLookupSubclass7() throws Throwable { // S2 overrides setAccessible Method m = S2.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == S2.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(inaccessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(inaccessibleField(), true)); } /** @@ -373,7 +367,7 @@ public class CallerSensitiveAccess { // Field::getInt mh = MethodHandles.lookup().findVirtual(Field.class, "getInt", MethodType.methodType(int.class, Object.class)); int value = (int)mh.invokeExact(f, (Object)null); - assertTrue(value == 5); + assertEquals(5, value); } private static class Inner { @@ -400,7 +394,7 @@ public class CallerSensitiveAccess { * exported by a named module. */ static Stream callerSensitiveMethods(Module module) { - assert module.isNamed(); + assertTrue(module.isNamed()); ModuleReference mref = module.getLayer().configuration() .findModule(module.getName()) .orElseThrow(() -> new RuntimeException()) diff --git a/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java b/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java index 0357afce668..4a2ad3f3091 100644 --- a/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java +++ b/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,12 +27,10 @@ * @summary Test bootstrap methods throwing an exception * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng BootstrapMethodJumboArgsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 BootstrapMethodJumboArgsTest + * @run junit BootstrapMethodJumboArgsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 BootstrapMethodJumboArgsTest */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.ConstantCallSite; @@ -43,6 +41,10 @@ import java.util.stream.IntStream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + public class BootstrapMethodJumboArgsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -93,7 +95,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -103,7 +105,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -113,7 +115,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } } @@ -128,7 +130,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -138,7 +140,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -148,7 +150,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } } } diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMException.java b/test/jdk/java/lang/invoke/condy/CondyBSMException.java index 7aa25c5cd95..1c9f867bc8b 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMException.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,12 +27,10 @@ * @summary Test bootstrap methods throwing an exception * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMException - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMException + * @run junit CondyBSMException + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMException */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -41,6 +39,10 @@ import java.lang.reflect.Constructor; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyBSMException { @Test @@ -70,26 +72,17 @@ public class CondyBSMException { static void test(String message, Class... ts) { MethodHandle mh = thrower(message, ts[ts.length - 1]); - Throwable caught = null; - try { - mh.invoke(); - } catch (Throwable t) { - caught = t; - } - - if (caught == null) { - Assert.fail("Throwable expected"); - } + Throwable caught = assertThrows(Throwable.class, mh::invoke); String actualMessage = null; for (int i = 0; i < ts.length; i++) { + int level = i; + assertInstanceOf(ts[i], caught, () -> "Level %d".formatted(level)); actualMessage = caught.getMessage(); - Assert.assertNotNull(caught); - Assert.assertTrue(ts[i].isAssignableFrom(caught.getClass())); caught = caught.getCause(); } - Assert.assertEquals(actualMessage, message); + assertEquals(message, actualMessage); } static Throwable throwingBsm(MethodHandles.Lookup l, String name, Class type) throws Throwable { diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java b/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java index e9050126a79..897ee40b444 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,13 +27,10 @@ * @summary Test basic invocation of bootstrap methods * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMInvocation - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMInvocation + * @run junit CondyBSMInvocation + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMInvocation */ - -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.ConstantDesc; @@ -48,6 +45,10 @@ import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyBSMInvocation { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -59,11 +60,7 @@ public class CondyBSMInvocation { "bsm", methodType(Object.class) ); - try { - mh.invoke(); - Assert.fail("NoSuchMethodError expected to be thrown"); - } catch (NoSuchMethodError e) { - } + assertThrows(NoSuchMethodError.class, mh::invoke); } static MethodHandle[] bsms(String bsmName) { @@ -114,11 +111,7 @@ public class CondyBSMInvocation { "shape_bsm", bsm.type() ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for " + bsm); - } catch (BootstrapMethodError e) { - } + assertThrows(BootstrapMethodError.class, mh::invoke); } } @@ -139,11 +132,7 @@ public class CondyBSMInvocation { "sig_bsm", bsm.type() ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for " + bsm); - } catch (BootstrapMethodError e) { - } + assertThrows(BootstrapMethodError.class, mh::invoke); } } @@ -202,7 +191,7 @@ public class CondyBSMInvocation { static void assertAll(Object... as) { for (int i = 0; i < as.length; i++) { - Assert.assertEquals(as[i], i); + assertEquals(i, as[i]); } } @@ -219,7 +208,7 @@ public class CondyBSMInvocation { ); Object r = mh.invoke(); - Assert.assertEquals(r, Integer.toString(n)); + assertEquals(Integer.toString(n), r); } { @@ -231,7 +220,7 @@ public class CondyBSMInvocation { ); Object r = mh.invoke(); - Assert.assertEquals(r, Integer.toString(9)); + assertEquals(Integer.toString(9), r); } } @@ -248,13 +237,8 @@ public class CondyBSMInvocation { IntStream.range(0, n - 1).boxed().toArray(ConstantDesc[]::new) ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for arrity " + n); - } catch (BootstrapMethodError e) { - Throwable t = e.getCause(); - Assert.assertTrue(WrongMethodTypeException.class.isAssignableFrom(t.getClass())); - } + var e = assertThrows(BootstrapMethodError.class, mh::invoke); + assertInstanceOf(WrongMethodTypeException.class, e.getCause()); } } } diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java index d255202866f..e6c2aacea63 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,28 +27,29 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMValidationTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMValidationTest + * @run junit CondyBSMValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; -import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class CondyBSMValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final String BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class) .toMethodDescriptorString(); - @DataProvider - public Object[][] invalidSignaturesProvider() throws Exception { + public static Object[][] invalidSignaturesProvider() throws Exception { return Stream.of(BSM_TYPE.replace("(", ""), BSM_TYPE.replace(")", ""), BSM_TYPE.replace("(", "").replace(")", ""), @@ -57,15 +58,13 @@ public class CondyBSMValidationTest { .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "invalidSignaturesProvider") + @ParameterizedTest + @MethodSource("invalidSignaturesProvider") public void testInvalidBSMSignature(String sig) throws Exception { - try { - MethodHandle mh = InstructionHelper.ldcDynamicConstant( - L, "name", "Ljava/lang/Object;", - "bsm", sig - ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains("Bad method descriptor")); - } + var e = assertThrows(IllegalArgumentException.class, () -> InstructionHelper.ldcDynamicConstant( + L, "name", "Ljava/lang/Object;", + "bsm", sig + )); + assertTrue(e.getMessage().contains("Bad method descriptor")); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java b/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java index 9fd35ed21f0..fe477d87657 100644 --- a/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java +++ b/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, 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 @@ -27,20 +27,20 @@ * @summary Test for an interface using condy with default overpass methods * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyInterfaceWithOverpassMethods - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyInterfaceWithOverpassMethods + * @run junit CondyInterfaceWithOverpassMethods + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyInterfaceWithOverpassMethods */ import java.lang.classfile.ClassFile; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + public class CondyInterfaceWithOverpassMethods { interface A { int a(); @@ -52,14 +52,14 @@ public class CondyInterfaceWithOverpassMethods { // Generated class with methods containing condy ldc - Class gc; + static Class gc; public static Object bsm(MethodHandles.Lookup l, String name, Class type) { return name; } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { // interface B extends A { // // Overpass for method A.a // diff --git a/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java index 6178b85236b..b380c28dc94 100644 --- a/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,13 +27,10 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyNameValidationTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNameValidationTest + * @run junit CondyNameValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNameValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -43,12 +40,17 @@ import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class CondyNameValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final MethodType BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class); - @DataProvider - public Object[][] invalidNamesProvider() { + public static Object[][] invalidNamesProvider() { return Stream.of( new Object[]{"", "zero-length member name"}, new Object[]{".", "Invalid member name"}, @@ -59,26 +61,24 @@ public class CondyNameValidationTest { .toArray(Object[][]::new); } - @Test(dataProvider = "invalidNamesProvider") + @ParameterizedTest + @MethodSource("invalidNamesProvider") public void testInvalidNames(String name, String errMessContent) throws Exception { - try { - MethodHandle mh = InstructionHelper.ldcDynamicConstant( - L, name, Object.class, - "bsm", BSM_TYPE - ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains(errMessContent)); - } + var e = assertThrows(IllegalArgumentException.class, () -> InstructionHelper.ldcDynamicConstant( + L, name, Object.class, + "bsm", BSM_TYPE + )); + assertTrue(e.getMessage().contains(errMessContent)); } - @DataProvider - public Object[][] validNamesProvider() throws Exception { + public static Object[][] validNamesProvider() throws Exception { return Stream.of("", "") .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "validNamesProvider") + @ParameterizedTest + @MethodSource("validNamesProvider") public void testValidNames(String name) throws Exception { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, name, Object.class, diff --git a/test/jdk/java/lang/invoke/condy/CondyNestedTest.java b/test/jdk/java/lang/invoke/condy/CondyNestedTest.java index 8eb71ec93a3..192bbeaa46f 100644 --- a/test/jdk/java/lang/invoke/condy/CondyNestedTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyNestedTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -26,24 +26,25 @@ * @bug 8186046 * @summary Test nested dynamic constant declarations that are recursive * @compile CondyNestedTest_Code.jcod - * @run testng CondyNestedTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNestedTest + * @run junit CondyNestedTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNestedTest */ -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyNestedTest { static final Class[] THROWABLES = {InvocationTargetException.class, StackOverflowError.class}; private static final MethodHandles.Lookup L = MethodHandles.lookup(); - Class c; + static Class c; // static final MethodHandles.Lookup L = MethodHandles.lookup(); // @@ -243,28 +244,17 @@ public class CondyNestedTest { // } static void test(Method m, Class... ts) { - Throwable caught = null; - try { - m.invoke(null); - } catch (Throwable t) { - caught = t; - } + Throwable caught = assertThrows(Throwable.class, () -> m.invoke(null)); - if (caught == null) { - Assert.fail("Throwable expected"); - } - - String actualMessage = null; for (int i = 0; i < ts.length; i++) { - actualMessage = caught.getMessage(); - Assert.assertNotNull(caught); - Assert.assertTrue(ts[i].isAssignableFrom(caught.getClass())); + int level = i; + assertInstanceOf(ts[i], caught, () -> "Level %d".formatted(level)); caught = caught.getCause(); } } - @BeforeClass - public void findClass() throws Exception { + @BeforeAll + public static void findClass() throws Exception { c = Class.forName("CondyNestedTest_Code"); } diff --git a/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java b/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java index 7ef5c610150..b7ccb4944fb 100644 --- a/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java +++ b/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -26,28 +26,28 @@ * @bug 8186211 * @summary Test basic invocation of multiple ldc's of the same dynamic constant that fail resolution * @library /java/lang/invoke/common - * @run testng CondyRepeatFailedResolution - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyRepeatFailedResolution + * @run junit CondyRepeatFailedResolution + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyRepeatFailedResolution */ import java.lang.classfile.ClassFile; -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyRepeatFailedResolution { // Counter used to determine if a given BSM is invoked more than once static int bsm_called = 0; // Generated class with methods containing condy ldc - Class gc; + static Class gc; // Bootstrap method used to represent primitive values // that cannot be represented directly in the constant pool, @@ -90,8 +90,8 @@ public class CondyRepeatFailedResolution { } } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { String genClassName = CondyRepeatFailedResolution.class.getSimpleName() + "$Code"; String bsmClassDesc = CondyRepeatFailedResolution.class.descriptorString(); String bsmMethodName = "intConversion"; @@ -319,29 +319,21 @@ public class CondyRepeatFailedResolution { Method m = gc.getDeclaredMethod(name); bsm_called = 0; - try { + InvocationTargetException e1 = assertThrows(InvocationTargetException.class, () -> { Object r1 = m.invoke(null); - Assert.fail("InvocationTargetException expected to be thrown after first invocation"); - } catch (InvocationTargetException e1) { - // bsm_called should have been incremented prior to the exception - Assert.assertEquals(bsm_called, 1); - Assert.assertTrue(e1.getCause() instanceof BootstrapMethodError); - // Try invoking method again to ensure that the bootstrap - // method is not invoked twice and a resolution failure - // results. - try { - Object r2 = m.invoke(null); - Assert.fail("InvocationTargetException expected to be thrown after second invocation"); - } catch (InvocationTargetException e2) { - // bsm_called should remain at 1 since the bootstrap - // method should not have been invoked. - Assert.assertEquals(bsm_called, 1); - Assert.assertTrue(e2.getCause() instanceof BootstrapMethodError); - } catch (Throwable t2) { - Assert.fail("InvocationTargetException expected to be thrown"); - } - } catch (Throwable t1) { - Assert.fail("InvocationTargetException expected to be thrown"); - } + }); + // bsm_called should have been incremented prior to the exception + assertEquals(1, bsm_called); + assertInstanceOf(BootstrapMethodError.class, e1.getCause()); + // Try invoking method again to ensure that the bootstrap + // method is not invoked twice and a resolution failure + // results. + InvocationTargetException e2 = assertThrows(InvocationTargetException.class, () -> { + Object r2 = m.invoke(null); + }); + // bsm_called should remain at 1 since the bootstrap + // method should not have been invoked. + assertEquals(1, bsm_called); + assertInstanceOf(BootstrapMethodError.class, e2.getCause()); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java b/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java index d6c0748c97c..4c0dd42a1a2 100644 --- a/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -25,22 +25,23 @@ * @test * @bug 8186046 * @summary Test for condy BSMs returning primitive values or null - * @run testng CondyReturnPrimitiveTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyReturnPrimitiveTest + * @run junit CondyReturnPrimitiveTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyReturnPrimitiveTest */ import java.lang.classfile.ClassFile; -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.Method; import java.util.concurrent.atomic.AtomicInteger; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class CondyReturnPrimitiveTest { // Counter for number of BSM calls // Use of an AtomicInteger is not strictly necessary in this test @@ -49,7 +50,7 @@ public class CondyReturnPrimitiveTest { // constant so care should be taken if a BSM operates on shared state static final AtomicInteger callCount = new AtomicInteger(); // Generated class with methods containing condy ldc - Class gc; + static Class gc; // Bootstrap method used to represent primitive values // that cannot be represented directly in the constant pool, @@ -90,8 +91,8 @@ public class CondyReturnPrimitiveTest { } } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { String genClassName = CondyReturnPrimitiveTest.class.getSimpleName() + "$Code"; String bsmClassDesc = CondyReturnPrimitiveTest.class.descriptorString(); String bsmMethodName = "intConversion"; @@ -293,7 +294,7 @@ public class CondyReturnPrimitiveTest { // Ensure when run a second time that the bootstrap method is not // invoked and the constants are cached testConstants(); - Assert.assertEquals(callCount.get(), expectedCallCount); + assertEquals(expectedCallCount, callCount.get()); } @Test @@ -318,11 +319,16 @@ public class CondyReturnPrimitiveTest { testConstant("S", Short.MAX_VALUE); testConstant("Z_F", false); testConstant("Z_T", true); - testConstant("null", null); + testConstant("null", (Object) null); } void testConstant(String name, Object expected) throws Exception { Method m = gc.getDeclaredMethod(name); - Assert.assertEquals(m.invoke(null), expected); + assertEquals(expected, m.invoke(null)); + } + + void testConstant(String name, Object[] expected) throws Exception { + Method m = gc.getDeclaredMethod(name); + assertArrayEquals(expected, (Object[]) m.invoke(null)); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java b/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java index ba3d0e81488..075eaf4e844 100644 --- a/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,12 +27,10 @@ * @summary Test bootstrap arguments for condy * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyStaticArgumentsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyStaticArgumentsTest + * @run junit CondyStaticArgumentsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyStaticArgumentsTest */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.*; @@ -44,6 +42,9 @@ import java.util.StringJoiner; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class CondyStaticArgumentsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -109,7 +110,7 @@ public class CondyStaticArgumentsTest { mhi.getName(), MethodTypeDesc.ofDescriptor(mhi.getMethodType().descriptorString())) ); - Assert.assertEquals(mh.invoke(), "constant-name-String-1-2-3.0-4.0-Number-something-(int,long,float,double)void-11"); + assertEquals("constant-name-String-1-2-3.0-4.0-Number-something-(int,long,float,double)void-11", mh.invoke()); } static MathContext mathContext(MethodHandles.Lookup l, String value, Class type) { @@ -161,7 +162,7 @@ public class CondyStaticArgumentsTest { ) ) ); - Assert.assertEquals(mh.invoke(), "big-decimal-math-context-String-3.141593-7"); + assertEquals("big-decimal-math-context-String-3.141593-7", mh.invoke()); } @@ -194,7 +195,7 @@ public class CondyStaticArgumentsTest { InstructionHelper.classDesc(MathContext.class) ) )); - Assert.assertEquals(mh.invoke(), "big-decimal-math-context-()Ljava/lang/String;-3.141593-7"); + assertEquals("big-decimal-math-context-()Ljava/lang/String;-3.141593-7", mh.invoke()); } private static DirectMethodHandleDesc directMhDesc(String methodName) { diff --git a/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java index c44179ce13c..4429468bd34 100644 --- a/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,12 +27,9 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyTypeValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyTypeValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -43,14 +40,18 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class CondyTypeValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final String BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class) .toMethodDescriptorString(); - @DataProvider - public Object[][] invalidTypesProvider() { + public static Object[][] invalidTypesProvider() { return Stream.of( // ByteCode API checks for the following invalid types // "", @@ -66,20 +67,19 @@ public class CondyTypeValidationTest { ).toArray(Object[][]::new); } - @Test(dataProvider = "invalidTypesProvider") + @ParameterizedTest + @MethodSource("invalidTypesProvider") public void testInvalidTypes(String type, String errMessContent) throws Exception { - try { + var e = assertThrows(IllegalArgumentException.class, () -> { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, "name", type, "bsm", BSM_TYPE ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains(errMessContent)); - } + }); + assertTrue(e.getMessage().contains(errMessContent)); } - @DataProvider - public Object[][] validTypesProvider() { + public static Object[][] validTypesProvider() { List t = new ArrayList<>(List.of("B", "C", "D", "F", "I", "J", "Ljava/lang/Object;", "S", "Z")); int l = t.size(); for (int i = 0; i < l; i++) { @@ -90,7 +90,8 @@ public class CondyTypeValidationTest { .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "validTypesProvider") + @ParameterizedTest + @MethodSource("validTypesProvider") public void testValidTypes(String type) throws Exception { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, "name", type, diff --git a/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java b/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java index 5e301a193dd..a00f93b69b7 100644 --- a/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,21 +27,20 @@ * @summary Stress test ldc to ensure HotSpot correctly manages oop maps * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyWithGarbageTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWithGarbageTest + * @run junit CondyWithGarbageTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWithGarbageTest */ - import java.lang.classfile.ClassFile; import java.lang.classfile.CodeBuilder; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; import static test.java.lang.invoke.lib.InstructionHelper.classDesc; public class CondyWithGarbageTest { @@ -54,7 +53,7 @@ public class CondyWithGarbageTest { for (int i = 0; i < 100000; i++) { l += +((String) mh.invoke()).length(); } - Assert.assertTrue(l > 0); + assertTrue(l > 0); } public static Object bsmString(MethodHandles.Lookup l, @@ -133,7 +132,7 @@ public class CondyWithGarbageTest { for (int i = 0; i < 100000; i++) { l += +((String) mh.invoke()).length(); } - Assert.assertTrue(l > 0); + assertTrue(l > 0); } public static Object bsmStringArray(MethodHandles.Lookup l, diff --git a/test/jdk/java/lang/invoke/condy/CondyWrongType.java b/test/jdk/java/lang/invoke/condy/CondyWrongType.java index 42c69e8ab7d..1c00da922fe 100644 --- a/test/jdk/java/lang/invoke/condy/CondyWrongType.java +++ b/test/jdk/java/lang/invoke/condy/CondyWrongType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -27,13 +27,10 @@ * @summary Test bootstrap methods returning the wrong type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyWrongType - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWrongType + * @run junit CondyWrongType + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWrongType */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -46,11 +43,15 @@ import java.util.List; import java.util.Map; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; public class CondyWrongType { - @DataProvider - public Object[][] primitivesProvider() throws Exception { + public static Object[][] primitivesProvider() throws Exception { Map> typeMap = Map.of( "B", byte.class, "C", char.class, @@ -81,7 +82,8 @@ public class CondyWrongType { return cases.stream().toArray(Object[][]::new); } - @Test(dataProvider = "primitivesProvider") + @ParameterizedTest + @MethodSource("primitivesProvider") public void testPrimitives(String name, String type, boolean pass) { test(name, type, pass); } @@ -106,27 +108,12 @@ public class CondyWrongType { static void test(String name, String type, boolean pass) { MethodHandle mh = caster(name, type); - Throwable caught = null; - try { - mh.invoke(); - } catch (Throwable t) { - caught = t; + if (pass) { + assertDoesNotThrow(() -> mh.invoke()); + } else { + Throwable caught = assertThrows(BootstrapMethodError.class, () -> mh.invoke()); + assertInstanceOf(ClassCastException.class, caught.getCause()); } - - if (caught == null) { - if (pass) { - return; - } else { - Assert.fail("Throwable expected"); - } - } else if (pass) { - Assert.fail("Throwable not expected"); - } - - Assert.assertTrue(BootstrapMethodError.class.isAssignableFrom(caught.getClass())); - caught = caught.getCause(); - Assert.assertNotNull(caught); - Assert.assertTrue(ClassCastException.class.isAssignableFrom(caught.getClass())); } static Object bsm(MethodHandles.Lookup l, String name, Class type) { diff --git a/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java b/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java index 829f26704f9..cef5a17eda1 100644 --- a/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java +++ b/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java @@ -27,27 +27,31 @@ * @summary Test dynamic constant bootstraps * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng ConstantBootstrapsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 ConstantBootstrapsTest + * @run junit ConstantBootstrapsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 ConstantBootstrapsTest */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import test.java.lang.invoke.lib.InstructionHelper; - import java.lang.constant.ConstantDescs; import java.lang.constant.DirectMethodHandleDesc; import java.lang.constant.MethodHandleDesc; -import java.lang.invoke.*; +import java.lang.invoke.ConstantBootstraps; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; +import java.lang.invoke.VarHandle; +import java.lang.invoke.WrongMethodTypeException; import java.math.BigInteger; import java.util.Collection; import java.util.List; import java.util.Map; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertNull; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import test.java.lang.invoke.lib.InstructionHelper; + +import static org.junit.jupiter.api.Assertions.*; -@Test public class ConstantBootstrapsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -56,6 +60,7 @@ public class ConstantBootstrapsTest { appendParameterTypes(params); } + @Test public void testNullConstant() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "_", Object.class, ConstantBootstraps.class, "nullConstant", lookupMT(Object.class)); @@ -66,12 +71,13 @@ public class ConstantBootstrapsTest { assertNull(handle.invoke()); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testNullConstantPrimitiveClass() { - ConstantBootstraps.nullConstant(MethodHandles.lookup(), null, int.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.nullConstant(MethodHandles.lookup(), null, int.class)); } + @Test public void testPrimitiveClass() throws Throwable { var pm = Map.of( "I", int.class, @@ -88,69 +94,73 @@ public class ConstantBootstrapsTest { for (var desc : pm.keySet()) { var handle = InstructionHelper.ldcDynamicConstant(L, desc, Class.class, ConstantBootstraps.class, "primitiveClass", lookupMT(Class.class)); - assertEquals(handle.invoke(), pm.get(desc)); + assertEquals(pm.get(desc), handle.invoke()); } } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testPrimitiveClassNullName() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), null, Class.class); + assertThrows(NullPointerException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), null, Class.class)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testPrimitiveClassNullType() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "I", null); + assertThrows(NullPointerException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "I", null)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassEmptyName() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "", Class.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassWrongNameChar() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "L", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "L", Class.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassWrongNameString() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "Ljava/lang/Object;", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "Ljava/lang/Object;", Class.class)); } + @Test public void testEnumConstant() throws Throwable { for (var v : StackWalker.Option.values()) { var handle = InstructionHelper.ldcDynamicConstant(L, v.name(), StackWalker.Option.class, ConstantBootstraps.class, "enumConstant", lookupMT(Enum.class)); - assertEquals(handle.invoke(), v); + assertEquals(v, handle.invoke()); } } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testEnumConstantUnknown() { - ConstantBootstraps.enumConstant(MethodHandles.lookup(), "DOES_NOT_EXIST", StackWalker.Option.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.enumConstant(MethodHandles.lookup(), "DOES_NOT_EXIST", StackWalker.Option.class)); } + @Test public void testGetStaticDecl() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "TYPE", Class.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class, Class.class), InstructionHelper.classDesc(Integer.class)); - assertEquals(handle.invoke(), int.class); + assertEquals(int.class, handle.invoke()); } + @Test public void testGetStaticSelf() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "MAX_VALUE", int.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class)); - assertEquals(handle.invoke(), Integer.MAX_VALUE); + assertEquals(Integer.MAX_VALUE, handle.invoke()); handle = InstructionHelper.ldcDynamicConstant(L, "ZERO", BigInteger.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class)); - assertEquals(handle.invoke(), BigInteger.ZERO); + assertEquals(BigInteger.ZERO, handle.invoke()); } + @Test public void testInvoke() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", List.class, @@ -159,9 +169,10 @@ public class ConstantBootstrapsTest { MethodType.methodType(List.class, Object[].class).toMethodDescriptorString()), 1, 2, 3, 4 ); - assertEquals(handle.invoke(), List.of(1, 2, 3, 4)); + assertEquals(List.of(1, 2, 3, 4), handle.invoke()); } + @Test public void testInvokeAsType() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", int.class, @@ -170,9 +181,10 @@ public class ConstantBootstrapsTest { MethodType.methodType(Integer.class, String.class).toMethodDescriptorString()), "42" ); - assertEquals(handle.invoke(), 42); + assertEquals(42, handle.invoke()); } + @Test public void testInvokeAsTypeVariableArity() throws Throwable { // The constant type is Collection but the invoke return type is List var handle = InstructionHelper.ldcDynamicConstant( @@ -182,21 +194,21 @@ public class ConstantBootstrapsTest { MethodType.methodType(List.class, Object[].class).toMethodDescriptorString()), 1, 2, 3, 4 ); - assertEquals(handle.invoke(), List.of(1, 2, 3, 4)); + assertEquals(List.of(1, 2, 3, 4), handle.invoke()); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testInvokeAsTypeClassCast() throws Throwable { - ConstantBootstraps.invoke(MethodHandles.lookup(), "_", String.class, + assertThrows(ClassCastException.class, () -> ConstantBootstraps.invoke(MethodHandles.lookup(), "_", String.class, MethodHandles.lookup().findStatic(Integer.class, "valueOf", MethodType.methodType(Integer.class, String.class)), - "42"); + "42")); } - @Test(expectedExceptions = WrongMethodTypeException.class) + @Test public void testInvokeAsTypeWrongReturnType() throws Throwable { - ConstantBootstraps.invoke(MethodHandles.lookup(), "_", short.class, + assertThrows(WrongMethodTypeException.class, () -> ConstantBootstraps.invoke(MethodHandles.lookup(), "_", short.class, MethodHandles.lookup().findStatic(Integer.class, "parseInt", MethodType.methodType(int.class, String.class)), - "42"); + "42")); } @@ -205,6 +217,7 @@ public class ConstantBootstrapsTest { public static String sf; } + @Test public void testVarHandleField() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "f", VarHandle.class, @@ -214,10 +227,11 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of(X.class)); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(X.class), vhandle.coordinateTypes()); } + @Test public void testVarHandleStaticField() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "sf", VarHandle.class, @@ -227,10 +241,11 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of()); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(), vhandle.coordinateTypes()); } + @Test public void testVarHandleArray() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", VarHandle.class, @@ -239,11 +254,10 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of(String[].class, int.class)); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(String[].class, int.class), vhandle.coordinateTypes()); } - @DataProvider public static Object[][] cceCasts() { return new Object[][]{ { void.class, null }, @@ -252,12 +266,12 @@ public class ConstantBootstrapsTest { }; } - @Test(dataProvider = "cceCasts", expectedExceptions = ClassCastException.class) + @ParameterizedTest + @MethodSource("cceCasts") public void testBadCasts(Class dstType, Object value) { - ConstantBootstraps.explicitCast(null, null, dstType, value); + assertThrows(ClassCastException.class, () -> ConstantBootstraps.explicitCast(null, null, dstType, value)); } - @DataProvider public static Object[][] validCasts() { Object o = new Object(); return new Object[][]{ @@ -278,9 +292,10 @@ public class ConstantBootstrapsTest { }; } - @Test(dataProvider = "validCasts") + @ParameterizedTest + @MethodSource("validCasts") public void testSuccessfulCasts(Class dstType, Object value, Object expected) { Object actual = ConstantBootstraps.explicitCast(null, null, dstType, value); - assertEquals(actual, expected); + assertEquals(expected, actual); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java index 379ae765a6b..097e7c782a5 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -31,7 +31,7 @@ * BadClassFileVersion.jcod * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm BasicTest + * @run junit/othervm BasicTest */ import java.io.File; @@ -52,16 +52,16 @@ import java.util.stream.Stream; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import static java.lang.classfile.ClassFile.*; import static java.lang.constant.ConstantDescs.CD_Enum; import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; interface HiddenTest { void test(); @@ -75,7 +75,7 @@ public class BasicTest { private static byte[] hiddenClassBytes; - @BeforeTest + @BeforeAll static void setup() throws IOException { compileSources(SRC_DIR, CLASSES_DIR); hiddenClassBytes = Files.readAllBytes(CLASSES_DIR.resolve("HiddenClass.class")); @@ -114,9 +114,9 @@ public class BasicTest { Class[] intfs = c.getInterfaces(); assertTrue(c.isHidden()); assertFalse(c.isPrimitive()); - assertTrue(intfs.length == 1); - assertTrue(intfs[0] == HiddenTest.class); - assertTrue(c.getCanonicalName() == null); + assertEquals(1, intfs.length); + assertSame(HiddenTest.class, intfs[0]); + assertNull(c.getCanonicalName()); String hcName = "HiddenClass"; String hcSuffix = "0x[0-9a-f]+"; @@ -143,7 +143,7 @@ public class BasicTest { Object array = Array.newInstance(type, 2); Class arrayType = array.getClass(); assertTrue(arrayType.isArray()); - assertTrue(Array.getLength(array) == 2); + assertEquals(2, Array.getLength(array)); assertFalse(arrayType.isHidden()); String hcName = "HiddenClass"; @@ -152,11 +152,11 @@ public class BasicTest { assertTrue(arrayType.descriptorString().matches("\\[" + "L" + hcName + "." + hcSuffix + ";")); assertTrue(arrayType.getComponentType().isHidden()); - assertTrue(arrayType.getComponentType() == type); + assertSame(type, arrayType.getComponentType()); Object t = type.newInstance(); Array.set(array, 0, t); Object o = Array.get(array, 0); - assertTrue(o == t); + assertSame(t, o); } private void checkSetAccessible(Class c, String name, Class... ptypes) throws Exception { @@ -170,13 +170,8 @@ public class BasicTest { @Test public void testLambda() throws Throwable { HiddenTest t = (HiddenTest)defineHiddenClass("Lambda").newInstance(); - try { - t.test(); - } catch (Error e) { - if (!e.getMessage().equals("thrown by " + t.getClass().getName())) { - throw e; - } - } + var e = assertThrows(Error.class, t::test); + assertEquals("thrown by " + t.getClass().getName(), e.getMessage()); } // Define a hidden class that uses lambda and contains its implementation @@ -184,13 +179,8 @@ public class BasicTest { @Test public void testHiddenLambda() throws Throwable { HiddenTest t = (HiddenTest)defineHiddenClass("HiddenLambda").newInstance(); - try { - t.test(); - } catch (Error e) { - if (!e.getMessage().equals("thrown by " + t.getClass().getName())) { - throw e; - } - } + var e = assertThrows(Error.class, t::test); + assertEquals("thrown by " + t.getClass().getName(), e.getMessage()); } // Verify the nest host and nest members of a hidden class and hidden nestmate class @@ -206,19 +196,18 @@ public class BasicTest { // test nest membership and reflection API assertTrue(host.isNestmateOf(member)); - assertTrue(host.getNestHost() == host); + assertSame(host, host.getNestHost()); // getNestHost and getNestMembers return the same value when calling // on a nest member and the nest host - assertTrue(member.getNestHost() == host.getNestHost()); - assertTrue(Arrays.equals(member.getNestMembers(), host.getNestMembers())); + assertSame(host.getNestHost(), member.getNestHost()); + assertArrayEquals(member.getNestMembers(), host.getNestMembers()); // getNestMembers includes the nest host that can be a hidden class but // only includes static nest members - assertTrue(host.getNestMembers().length == 1); - assertTrue(host.getNestMembers()[0] == host); + assertEquals(1, host.getNestMembers().length); + assertSame(host, host.getNestMembers()[0]); } - @DataProvider(name = "hiddenClasses") - private Object[][] hiddenClasses() { + private static Object[][] hiddenClasses() { return new Object[][] { new Object[] { "HiddenInterface", false }, new Object[] { "AbstractClass", false }, @@ -240,7 +229,8 @@ public class BasicTest { * is not useful as it cannot be referenced and an outer/inner class * when defined as a hidden effectively becomes a final top-level class. */ - @Test(dataProvider = "hiddenClasses") + @ParameterizedTest + @MethodSource("hiddenClasses") public void defineHiddenClass(String name, boolean nestmate) throws Exception { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve(name + ".class")); Class hc; @@ -252,13 +242,12 @@ public class BasicTest { hc = lookup().defineHiddenClass(bytes, false).lookupClass(); host = hc; } - assertTrue(hc.getNestHost() == host); - assertTrue(hc.getNestMembers().length == 1); - assertTrue(hc.getNestMembers()[0] == host); + assertSame(host, hc.getNestHost()); + assertEquals(1, hc.getNestMembers().length); + assertSame(host, hc.getNestMembers()[0]); } - @DataProvider(name = "emptyClasses") - private Object[][] emptyClasses() { + private static Object[][] emptyClasses() { return new Object[][] { new Object[] { "EmptyHiddenSynthetic", ACC_SYNTHETIC }, new Object[] { "EmptyHiddenEnum", ACC_ENUM }, @@ -276,7 +265,8 @@ public class BasicTest { * enum class containing constants of its type should not be a hidden * class. */ - @Test(dataProvider = "emptyClasses") + @ParameterizedTest + @MethodSource("emptyClasses") public void emptyHiddenClass(String name, int accessFlags) throws Exception { byte[] bytes = (accessFlags == ACC_ENUM) ? classBytes(name, CD_Enum, accessFlags) : classBytes(name, accessFlags); @@ -316,7 +306,7 @@ public class BasicTest { throw new IllegalArgumentException("unexpected access flag: " + accessFlags); } assertTrue(hc.isHidden()); - assertTrue(hc.getModifiers() == (ACC_PUBLIC|accessFlags)); + assertEquals(hc.getModifiers(), ACC_PUBLIC | accessFlags); assertFalse(hc.isLocalClass()); assertFalse(hc.isMemberClass()); assertFalse(hc.isAnonymousClass()); @@ -324,8 +314,7 @@ public class BasicTest { } // These class files can't be defined as hidden classes - @DataProvider(name = "cantBeHiddenClasses") - private Object[][] cantBeHiddenClasses() { + private static Object[][] cantBeHiddenClasses() { return new Object[][] { // a hidden class can't be a field's declaring type // enum class with static final HiddenEnum[] $VALUES: @@ -342,10 +331,11 @@ public class BasicTest { /* * These class files */ - @Test(dataProvider = "cantBeHiddenClasses", expectedExceptions = NoClassDefFoundError.class) + @ParameterizedTest + @MethodSource("cantBeHiddenClasses") public void failToDeriveAsHiddenClass(String name) throws Exception { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve(name + ".class")); - Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); + assertThrows(NoClassDefFoundError.class, () -> lookup().defineHiddenClass(bytes, false).lookupClass()); } /* @@ -361,22 +351,17 @@ public class BasicTest { Class c = t.getClass(); Class[] intfs = c.getInterfaces(); - assertTrue(intfs.length == 1); - assertTrue(intfs[0] == HiddenTest.class); + assertEquals(1, intfs.length); + assertSame(HiddenTest.class, intfs[0]); - try { - // this would cause loading of class HiddenCantReflect and NCDFE due - // to error during verification - c.getDeclaredMethods(); - } catch (NoClassDefFoundError e) { - Throwable x = e.getCause(); - if (x == null || !(x instanceof ClassNotFoundException && x.getMessage().contains("HiddenCantReflect"))) { - throw e; - } + var e = assertThrows(NoClassDefFoundError.class, c::getDeclaredMethods); + Throwable x = e.getCause(); + if (x == null || !(x instanceof ClassNotFoundException && x.getMessage().contains("HiddenCantReflect"))) { + throw e; } } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void cantDefineModule() throws Throwable { Path src = Paths.get("module-info.java"); Path dir = CLASSES_DIR.resolve("m"); @@ -384,35 +369,34 @@ public class BasicTest { compileSources(src, dir); byte[] bytes = Files.readAllBytes(dir.resolve("module-info.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(IllegalArgumentException.class, () -> lookup().defineHiddenClass(bytes, false)); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void cantDefineClassInAnotherPackage() throws Throwable { Path src = Paths.get("ClassInAnotherPackage.java"); Files.write(src, List.of("package p;", "public class ClassInAnotherPackage {}"), StandardCharsets.UTF_8); compileSources(src, CLASSES_DIR); byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("p").resolve("ClassInAnotherPackage.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(IllegalArgumentException.class, () -> lookup().defineHiddenClass(bytes, false)); } - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void lessPrivilegedLookup() throws Throwable { Lookup lookup = lookup().dropLookupMode(Lookup.PRIVATE); - lookup.defineHiddenClass(hiddenClassBytes, false); + assertThrows(IllegalAccessException.class, () -> lookup.defineHiddenClass(hiddenClassBytes, false)); } - @Test(expectedExceptions = { UnsupportedClassVersionError.class }) + @Test public void badClassFileVersion() throws Throwable { Path dir = Paths.get(System.getProperty("test.classes", ".")); byte[] bytes = Files.readAllBytes(dir.resolve("BadClassFileVersion.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(UnsupportedClassVersionError.class, () -> lookup().defineHiddenClass(bytes, false)); } // malformed class files - @DataProvider(name = "malformedClassFiles") - private Object[][] malformedClassFiles() throws IOException { + private static Object[][] malformedClassFiles() throws IOException { Path dir = Paths.get(System.getProperty("test.classes", ".")); return new Object[][] { // `this_class` has invalid CP entry @@ -424,13 +408,13 @@ public class BasicTest { }; } - @Test(dataProvider = "malformedClassFiles", expectedExceptions = ClassFormatError.class) + @ParameterizedTest + @MethodSource("malformedClassFiles") public void badClassFile(byte[] bytes) throws Throwable { - lookup().defineHiddenClass(bytes, false); + assertThrows(ClassFormatError.class, () -> lookup().defineHiddenClass(bytes, false)); } - @DataProvider(name = "nestedTypesOrAnonymousClass") - private Object[][] nestedTypesOrAnonymousClass() { + private static Object[][] nestedTypesOrAnonymousClass() { return new Object[][] { // class file with bad InnerClasses or EnclosingMethod attribute new Object[] { "Outer", null }, @@ -440,7 +424,8 @@ public class BasicTest { }; } - @Test(dataProvider = "nestedTypesOrAnonymousClass") + @ParameterizedTest + @MethodSource("nestedTypesOrAnonymousClass") public void hasInnerClassesOrEnclosingMethodAttribute(String className, String badDeclaringClassName) throws Throwable { byte[] bytes = Files.readAllBytes(CLASSES_10_DIR.resolve(className + ".class")); Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); @@ -460,21 +445,22 @@ public class BasicTest { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("Outer.class")); Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); assertHiddenClass(hc); - assertTrue(hc.getNestHost() == hc); + assertSame(hc, hc.getNestHost()); Class[] members = hc.getNestMembers(); - assertTrue(members.length == 1 && members[0] == hc); + assertEquals(1, members.length); + assertSame(hc, members[0]); } // a hidden class with bad InnerClasses or EnclosingMethod attribute private void hiddenClassWithBadAttribute(Class hc, String badDeclaringClassName) { assertTrue(hc.isHidden()); - assertTrue(hc.getCanonicalName() == null); + assertNull(hc.getCanonicalName()); assertTrue(hc.getName().contains("/")); if (badDeclaringClassName == null) { // the following reflection API assumes a good name in InnerClasses // or EnclosingMethod attribute can successfully be resolved. - assertTrue(hc.getSimpleName().length() > 0); + assertFalse(hc.getSimpleName().isEmpty()); assertFalse(hc.isAnonymousClass()); assertFalse(hc.isLocalClass()); assertFalse(hc.isMemberClass()); @@ -483,43 +469,34 @@ public class BasicTest { } // validation of nest membership - assertTrue(hc.getNestHost() == hc); + assertSame(hc, hc.getNestHost()); // validate the static nest membership Class[] members = hc.getNestMembers(); - assertTrue(members.length == 1 && members[0] == hc); + assertEquals(1, members.length); + assertSame(hc, members[0]); } // Class::getSimpleName, Class::isMemberClass private void declaringClassNotFound(Class c, String cn) { - try { - // fail to find declaring/enclosing class - c.isMemberClass(); - assertTrue(false); - } catch (NoClassDefFoundError e) { - if (!e.getMessage().equals(cn)) { - throw e; - } + var e = assertThrows(NoClassDefFoundError.class, c::isMemberClass); + if (!e.getMessage().equals(cn)) { + throw e; } - try { - // fail to find declaring/enclosing class - c.getSimpleName(); - assertTrue(false); - } catch (NoClassDefFoundError e) { - if (!e.getMessage().equals(cn)) { - throw e; - } + e = assertThrows(NoClassDefFoundError.class, c::getSimpleName); + if (!e.getMessage().equals(cn)) { + throw e; } } private static void singletonNest(Class hc) { - assertTrue(hc.getNestHost() == hc); - assertTrue(hc.getNestMembers().length == 1); - assertTrue(hc.getNestMembers()[0] == hc); + assertSame(hc, hc.getNestHost()); + assertEquals(1, hc.getNestMembers().length); + assertSame(hc, hc.getNestMembers()[0]); } private static void assertHiddenClass(Class hc) { assertTrue(hc.isHidden()); - assertTrue(hc.getCanonicalName() == null); + assertNull(hc.getCanonicalName()); assertTrue(hc.getName().contains("/")); assertFalse(hc.isAnonymousClass()); assertFalse(hc.isLocalClass()); diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java index e026a7a1387..a71029dd229 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -25,7 +25,7 @@ * @test * @library /test/lib * @build HiddenNestmateTest - * @run testng/othervm HiddenNestmateTest + * @run junit/othervm HiddenNestmateTest */ import java.lang.classfile.ClassFile; @@ -37,9 +37,6 @@ import java.lang.reflect.AccessFlag; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.stream.Stream; -import java.util.Arrays; - -import org.testng.annotations.Test; import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.constant.ConstantDescs.CD_int; @@ -48,7 +45,8 @@ import static java.lang.constant.ConstantDescs.MTD_void; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class HiddenNestmateTest { private static final ClassDesc CD_HiddenNestmateTest = HiddenNestmateTest.class.describeConstable().orElseThrow(); @@ -61,12 +59,12 @@ public class HiddenNestmateTest { Class hiddenClass = lookup.lookupClass(); Class nestHost = hiddenClass.getNestHost(); assertTrue(hiddenClass.isHidden()); - assertTrue(nestHost == MethodHandles.lookup().lookupClass()); + assertSame(MethodHandles.lookup().lookupClass(), nestHost); // hidden nestmate is not listed in the return array of getNestMembers assertTrue(Stream.of(nestHost.getNestMembers()).noneMatch(k -> k == hiddenClass)); assertTrue(hiddenClass.isNestmateOf(lookup.lookupClass())); - assertTrue(Arrays.equals(hiddenClass.getNestMembers(), nestHost.getNestMembers())); + assertArrayEquals(nestHost.getNestMembers(), hiddenClass.getNestMembers()); } /* @@ -78,23 +76,19 @@ public class HiddenNestmateTest { Lookup lookup = MethodHandles.lookup().defineHiddenClass(bytes, false); Class c = lookup.lookupClass(); assertTrue(lookup.hasFullPrivilegeAccess()); - assertTrue((lookup.lookupModes() & ORIGINAL) == ORIGINAL); - assertTrue(c.getNestHost() == c); // host of its own nest + assertEquals(ORIGINAL, lookup.lookupModes() & ORIGINAL); + assertSame(c, c.getNestHost()); // host of its own nest assertTrue(c.isHidden()); // invoke int test(HiddenNestmateTest o) via MethodHandle MethodHandle ctor = lookup.findConstructor(c, MethodType.methodType(void.class)); MethodHandle mh = lookup.findVirtual(c, "test", MethodType.methodType(int.class, HiddenNestmateTest.class)); - try { + assertThrows(IllegalAccessError.class, () -> { int x = (int) mh.bindTo(ctor.invoke()).invokeExact(this); - throw new RuntimeException("should fail when accessing HiddenNestmateTest.privMethod()"); - } catch (IllegalAccessError e) {} + }); // invoke int test(HiddenNestmateTest o) - try { - int x1 = testInjectedClass(c); - throw new RuntimeException("should fail when accessing HiddenNestmateTest.privMethod()"); - } catch (IllegalAccessError e) {} + assertThrows(IllegalAccessError.class, () -> testInjectedClass(c)); } /* @@ -111,11 +105,11 @@ public class HiddenNestmateTest { MethodHandle ctor = lookup.findConstructor(c, MethodType.methodType(void.class)); MethodHandle mh = lookup.findVirtual(c, "test", MethodType.methodType(int.class, HiddenNestmateTest.class)); int x = (int)mh.bindTo(ctor.invoke()).invokeExact( this); - assertTrue(x == privMethod()); + assertEquals(privMethod(), x); // invoke int test(HiddenNestmateTest o) int x1 = testInjectedClass(c); - assertTrue(x1 == privMethod()); + assertEquals(privMethod(), x1); } /* @@ -131,10 +125,10 @@ public class HiddenNestmateTest { /* * Fail to create a hidden class if dropping PRIVATE lookup mode */ - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void noPrivateLookupAccess() throws Throwable { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.PRIVATE); - lookup.defineHiddenClass(bytes, false, NESTMATE); + assertThrows(IllegalAccessException.class, () -> lookup.defineHiddenClass(bytes, false, NESTMATE)); } public void teleportToNestmate() throws Throwable { @@ -143,8 +137,8 @@ public class HiddenNestmateTest { // Teleport to a hidden nestmate Lookup lc = MethodHandles.lookup().in(lookup.lookupClass()); - assertTrue((lc.lookupModes() & PRIVATE) != 0); - assertTrue((lc.lookupModes() & ORIGINAL) == 0); + assertNotEquals(0, lc.lookupModes() & PRIVATE); + assertEquals(0, lc.lookupModes() & ORIGINAL); Lookup lc2 = lc.defineHiddenClass(bytes, false, NESTMATE); assertNestmate(lc2); @@ -153,9 +147,9 @@ public class HiddenNestmateTest { /* * Fail to create a hidden class in a different package from the lookup class' package */ - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void notSamePackage() throws Throwable { - MethodHandles.lookup().defineHiddenClass(classBytes("p/HiddenInjected"), false, NESTMATE); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().defineHiddenClass(classBytes("p/HiddenInjected"), false, NESTMATE)); } /* diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java index 9e3c8a8b318..7524e67bf9e 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -25,7 +25,7 @@ * @test * @summary define a lambda proxy class whose target class has an invalid * nest membership - * @run testng/othervm p.LambdaNestedInnerTest + * @run junit/othervm p.LambdaNestedInnerTest */ package p; @@ -41,11 +41,10 @@ import java.util.Arrays; import java.util.Set; import java.util.stream.Collectors; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; - import static java.nio.file.StandardCopyOption.REPLACE_EXISTING; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LambdaNestedInnerTest { private static final String INNER_CLASSNAME = "p.LambdaNestedInnerTest$Inner"; @@ -68,7 +67,7 @@ public class LambdaNestedInnerTest { lambda1.run(); } - // testng may not be visible to this class + // junit may not be visible to this class private static void assertTrue(boolean x) { if (!x) { throw new AssertionError("expected true but found false"); @@ -79,8 +78,8 @@ public class LambdaNestedInnerTest { } } - @BeforeTest - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { String filename = INNER_CLASSNAME.replace('.', File.separatorChar) + ".class"; Path src = Paths.get(System.getProperty("test.classes"), filename); Path dest = Paths.get(DIR, filename); @@ -93,9 +92,9 @@ public class LambdaNestedInnerTest { Class inner = Class.forName(INNER_CLASSNAME); // inner class is a nest member of LambdaNestedInnerTest Class nestHost = inner.getNestHost(); - assertTrue(nestHost == LambdaNestedInnerTest.class); + assertSame(LambdaNestedInnerTest.class, nestHost); Set> members = Arrays.stream(nestHost.getNestMembers()).collect(Collectors.toSet()); - assertEquals(members, Set.of(nestHost, inner, TestLoader.class)); + assertEquals(Set.of(nestHost, inner, TestLoader.class), members); // spin lambda proxy hidden class Runnable runnable = (Runnable) inner.newInstance(); @@ -107,8 +106,8 @@ public class LambdaNestedInnerTest { URL[] urls = new URL[] { Paths.get(DIR).toUri().toURL() }; URLClassLoader loader = new URLClassLoader(urls, null); Class inner = loader.loadClass(INNER_CLASSNAME); - assertTrue(inner.getClassLoader() == loader); - assertTrue(inner.getNestHost() == inner); // linkage error ignored + assertSame(loader, inner.getClassLoader()); + assertSame(inner, inner.getNestHost()); // linkage error ignored Runnable runnable = (Runnable) inner.newInstance(); // this validates the lambda proxy class @@ -125,8 +124,8 @@ public class LambdaNestedInnerTest { TestLoader loader = new TestLoader(urls); Class inner = loader.loadClass(INNER_CLASSNAME); - assertTrue(inner.getClassLoader() == loader); - assertTrue(inner.getNestHost() == inner); // linkage error ignored. + assertSame(loader, inner.getClassLoader()); + assertSame(inner, inner.getNestHost()); // linkage error ignored. Runnable runnable = (Runnable) inner.newInstance(); // this validates the lambda proxy class diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java b/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java index fddbb348517..bd6c87808fe 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -29,7 +29,7 @@ * @requires !java.enablePreview * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng PreviewHiddenClass + * @run junit PreviewHiddenClass * @summary verify UnsupportedClassVersionError thrown when defining a hidden class * with preview minor version but --enable-preview is not set * @comment This test itself cannot enablePreview, or hidden class definition @@ -46,15 +46,15 @@ import java.nio.file.Paths; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class PreviewHiddenClass { private static final Path SRC_DIR = Paths.get(Utils.TEST_SRC, "src"); private static final Path CLASSES_DIR = Paths.get("classes"); - @Test(expectedExceptions = { UnsupportedClassVersionError.class }) + @Test public void previewNotEnabled() throws Exception { // compile a class with --enable-preview Path sourceFile = SRC_DIR.resolve("HiddenInterface.java"); @@ -67,7 +67,7 @@ public class PreviewHiddenClass { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("HiddenInterface.class")); var dis = new DataInputStream(new ByteArrayInputStream(bytes)); dis.skipBytes(4); // 0xCAFEBABE - assertEquals(dis.readUnsignedShort(), 65535); // Minor version - MethodHandles.lookup().defineHiddenClass(bytes, false); + assertEquals(65535, dis.readUnsignedShort()); // Minor version + assertThrows(UnsupportedClassVersionError.class, () -> MethodHandles.lookup().defineHiddenClass(bytes, false)); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java index 1c95caa97d3..ac0a29c247d 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -27,7 +27,7 @@ * @summary hidden class members can't be statically invocable * @modules java.base/jdk.internal.misc * @build java.base/* - * @run testng StaticInvocableTest + * @run junit StaticInvocableTest */ import java.lang.classfile.ClassFile; @@ -38,7 +38,6 @@ import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; import java.lang.invoke.LookupHelper; import java.lang.reflect.AccessFlag; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; @@ -46,6 +45,7 @@ import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.constant.ConstantDescs.CD_int; import static java.lang.constant.ConstantDescs.INIT_NAME; import static java.lang.constant.ConstantDescs.MTD_void; +import org.junit.jupiter.api.Test; public class StaticInvocableTest { public static void main(String[] args) throws Throwable { diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java index e60cb8a5782..575eac1ccd1 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -21,10 +21,10 @@ * questions. */ -/** +/* * @test * @bug 8242013 - * @run testng/othervm test.TypeDescriptorTest + * @run junit/othervm test.TypeDescriptorTest * @summary Test TypeDescriptor::descriptorString for hidden classes which * cannot be used to produce ConstantDesc via ClassDesc or * MethodTypeDesc factory methods @@ -42,9 +42,10 @@ import java.nio.file.Files; import java.nio.file.Paths; import static java.lang.invoke.MethodType.*; -import org.testng.annotations.Test; -import org.testng.annotations.DataProvider; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TypeDescriptorTest { private static final Lookup HC_LOOKUP = defineHiddenClass(); @@ -61,8 +62,7 @@ public class TypeDescriptorTest { } } - @DataProvider(name = "constables") - private Object[][] constables() throws Exception { + private static Object[][] constables() throws Exception { Class hcArray = Array.newInstance(HC, 1).getClass(); return new Object[][] { new Object[] { HC }, @@ -79,7 +79,8 @@ public class TypeDescriptorTest { * Hidden classes have no nominal descriptor. * Constable::describeConstable returns empty optional. */ - @Test(dataProvider = "constables") + @ParameterizedTest + @MethodSource("constables") public void noNominalDescriptor(Constable constable) { assertTrue(constable.describeConstable().isEmpty()); } @@ -90,27 +91,13 @@ public class TypeDescriptorTest { */ @Test public void testClassDesc() { - try { - ClassDesc.ofDescriptor(HC.descriptorString()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - - try { - ClassDesc.ofDescriptor(HC.getName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - try { - ClassDesc.of(HC.getPackageName(), HC.getSimpleName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - try { - ClassDesc.of(HC.getName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(HC.descriptorString())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(HC.getName())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.of(HC.getPackageName(), HC.getSimpleName())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.of(HC.getName())); } - @DataProvider(name = "typeDescriptors") - private Object[][] typeDescriptors() throws Exception { + private static Object[][] typeDescriptors() throws Exception { Class hcArray = Array.newInstance(HC, 1, 1).getClass(); return new Object[][] { new Object[] { HC, "Ltest/HiddenClass.0x[0-9a-f]+;"}, @@ -124,26 +111,20 @@ public class TypeDescriptorTest { /* * Hidden classes have no nominal type descriptor */ - @Test(dataProvider = "typeDescriptors") + @ParameterizedTest + @MethodSource("typeDescriptors") public void testTypeDescriptor(TypeDescriptor td, String regex) throws Exception { String desc = td.descriptorString(); assertTrue(desc.matches(regex)); if (td instanceof Class) { - try { - ClassDesc.ofDescriptor(desc); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(desc)); } else if (td instanceof MethodType) { - try { - MethodTypeDesc.ofDescriptor(desc); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> MethodTypeDesc.ofDescriptor(desc)); } } - @DataProvider(name = "methodTypes") - private Object[][] methodTypes() throws Exception { + private static Object[][] methodTypes() throws Exception { Class hcArray = Array.newInstance(HC, 1, 1).getClass(); return new Object[][] { new Object[] { methodType(HC), "\\(\\)Ltest/HiddenClass.0x[0-9a-f]+;" }, @@ -155,15 +136,13 @@ public class TypeDescriptorTest { /* * Test MethodType::toMethodDescriptorString with MethodType referencing to hidden class */ - @Test(dataProvider = "methodTypes") + @ParameterizedTest + @MethodSource("methodTypes") public void testToMethodDescriptorString(MethodType mtype, String regex) throws Exception { String desc = mtype.toMethodDescriptorString(); assertTrue(desc.matches(regex)); - try { - MethodType.fromMethodDescriptorString(desc, TypeDescriptorTest.class.getClassLoader()); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> MethodType.fromMethodDescriptorString(desc, TypeDescriptorTest.class.getClassLoader())); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java index b016b2f6899..45728f2ed79 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -27,7 +27,7 @@ * @modules jdk.compiler * @library /test/lib/ * @build jdk.test.lib.util.ForceGC - * @run testng/othervm UnloadingTest + * @run junit/othervm UnloadingTest */ import java.io.IOException; @@ -48,18 +48,16 @@ import jdk.test.lib.util.ForceGC; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; - -import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class UnloadingTest { private static final Path CLASSES_DIR = Paths.get("classes"); private static byte[] hiddenClassBytes; - @BeforeTest + @BeforeAll static void setup() throws IOException { Path src = Paths.get(Utils.TEST_SRC, "src", "LookupHelper.java"); if (!CompilerUtils.compile(src, CLASSES_DIR)) { @@ -116,7 +114,7 @@ public class UnloadingTest { // keep a strong reference to the nest member class Class member = unloaders[1].weakRef.get(); - assertTrue(member != null); + assertNotNull(member); // nest host and member will not be unloaded assertFalse(unloaders[0].tryUnload()); assertFalse(unloaders[1].tryUnload()); @@ -180,7 +178,7 @@ public class UnloadingTest { } else { hc = lookup.defineHiddenClass(hiddenClassBytes, false).lookupClass(); } - assertTrue(hc.getClassLoader() == lookup.lookupClass().getClassLoader()); + assertSame(lookup.lookupClass().getClassLoader(), hc.getClassLoader()); return new HiddenClassUnloader(hc); } @@ -202,7 +200,7 @@ public class UnloadingTest { } else { member = hostLookup.defineHiddenClass(hiddenClassBytes, false, NESTMATE).lookupClass(); } - assertTrue(member.getNestHost() == host); + assertSame(host, member.getNestHost()); return new HiddenClassUnloader[] { new HiddenClassUnloader(host), new HiddenClassUnloader(member) }; } diff --git a/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java b/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java index 9b6622a7e9c..5bb7f67c000 100644 --- a/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java +++ b/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -21,12 +21,12 @@ * questions. */ -/** +/* * @test * @bug 8209005 8209078 * @library /test/lib * @build m1/* FindSpecialTest - * @run testng/othervm FindSpecialTest + * @run junit/othervm FindSpecialTest * @summary Test findSpecial and unreflectSpecial of the declaring class * of the method and the special caller are not in the same module * as the lookup class. @@ -39,7 +39,7 @@ import java.nio.file.Paths; import static jdk.test.lib.process.ProcessTools.*; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; public class FindSpecialTest { static final String TEST_CLASSES = System.getProperty("test.classes", "."); @@ -51,7 +51,7 @@ public class FindSpecialTest { * Run test.FindSpecial in unnamed module */ @Test - public static void callerInUnnamedModule() throws Throwable { + public void callerInUnnamedModule() throws Throwable { Path m1 = Paths.get(TEST_CLASSES, "modules", TEST_MODULE); if (Files.notExists(m1)) { throw new Error(m1 + " not exist"); @@ -66,7 +66,7 @@ public class FindSpecialTest { * Run test.FindSpecial in a named module */ @Test - public static void callerInNamedModule() throws Throwable { + public void callerInNamedModule() throws Throwable { Path modules = Paths.get(TEST_CLASSES, "modules"); if (Files.notExists(modules)) { throw new Error(modules + " not exist"); diff --git a/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java b/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java index 1f950ffce7e..6c505ddf471 100644 --- a/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java +++ b/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -21,36 +21,33 @@ * questions. */ -/** +/* * @test * @bug 8248231 * @summary Test to verify lambda serialization uses the correct UTF-8 encoding * @library /test/lib * @build jdk.test.lib.JDKToolFinder * jdk.test.lib.process.ProcessTools - * @run testng LambdaFileEncodingSerialization + * @run junit LambdaFileEncodingSerialization */ import java.io.File; -import java.io.BufferedReader; -import java.io.InputStreamReader; -import java.io.IOException; import java.util.List; import java.util.Map; import java.util.Arrays; import java.util.ArrayList; -import org.testng.annotations.Test; -import static org.testng.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import jdk.test.lib.JDKToolFinder; import jdk.test.lib.process.ProcessTools; +import org.junit.jupiter.api.Test; public class LambdaFileEncodingSerialization { private static final String TEST_NAME = "TestLambdaFileEncodingSerialization"; @Test - public static void testDeserializeLambdaEncoding() throws Throwable { + public void testDeserializeLambdaEncoding() throws Throwable { String javac = JDKToolFinder.getTestJDKTool("javac"); String java = JDKToolFinder.getTestJDKTool("java"); diff --git a/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java b/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java index aed19e6ca17..0dbdff79230 100644 --- a/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java +++ b/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java @@ -29,8 +29,7 @@ import java.util.function.IntSupplier; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; /* * @test @@ -62,7 +61,7 @@ public class LambdaHiddenCaller { void testSerializableLambda() { var is = hiddenCaller.callSerializableLambda(); assertEquals(42, is.getAsInt()); - assertTrue(Serializable.class.isAssignableFrom(is.getClass())); + assertInstanceOf(Serializable.class, is); // We do not guarantee serialization functionalities yet } } diff --git a/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java b/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java index 60c85753d72..eb013bf01f3 100644 --- a/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java +++ b/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2025, 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 @@ -29,7 +29,7 @@ * @library /java/nio/file * @modules jdk.compiler * jdk.zipfs - * @run testng LogGeneratedClassesTest + * @run junit LogGeneratedClassesTest * @summary tests logging generated classes for lambda */ import java.io.IOException; @@ -45,24 +45,24 @@ import java.nio.file.attribute.PosixFileAttributeView; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.process.OutputAnalyzer; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import org.testng.SkipException; import static java.nio.file.attribute.PosixFilePermissions.*; import static jdk.test.lib.process.ProcessTools.*; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LogGeneratedClassesTest { static final Path DUMP_LAMBDA_PROXY_CLASS_FILES = Path.of("DUMP_LAMBDA_PROXY_CLASS_FILES"); static final Path CLASSES = Path.of("classes").toAbsolutePath(); - String longFQCN; + static String longFQCN; - @BeforeClass - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { final List scratch = new ArrayList<>(); scratch.clear(); scratch.add("package com.example;"); @@ -102,8 +102,8 @@ public class LogGeneratedClassesTest { CompilerUtils.compile(Path.of("."), CLASSES); } - @AfterClass - public void cleanup() throws IOException { + @AfterAll + public static void cleanup() throws IOException { Files.delete(Paths.get("TestLambda.java")); Files.delete(Paths.get("LongPackageName.java")); TestUtil.removeAll(DUMP_LAMBDA_PROXY_CLASS_FILES); @@ -132,12 +132,11 @@ public class LogGeneratedClassesTest { executeProcess(pb).shouldHaveExitValue(0); // 2 our own class files. We don't care about the others - assertEquals(Files.find( - dumpDir, - 99, - (p, a) -> p.startsWith(dumpDir.resolve("com/example")) - && a.isRegularFile()).count(), - 2, "Two lambda captured"); + assertEquals(2, Files.find( + dumpDir, + 99, + (p, a) -> p.startsWith(dumpDir.resolve("com/example")) + && a.isRegularFile()).count(), "Two lambda captured"); } @Test @@ -155,12 +154,11 @@ public class LogGeneratedClassesTest { executeProcess(pb).shouldHaveExitValue(0); // The dump directory will be created if not exist - assertEquals(Files.find( - dumpDir, - 99, - (p, a) -> p.startsWith(dumpDir.resolve("com/example")) - && a.isRegularFile()).count(), - 2, "Two lambda captured"); + assertEquals(2, Files.find( + dumpDir, + 99, + (p, a) -> p.startsWith(dumpDir.resolve("com/example")) + && a.isRegularFile()).count(), "Two lambda captured"); } @Test @@ -208,12 +206,10 @@ public class LogGeneratedClassesTest { try { fs = Files.getFileStore(Paths.get(".")); } catch (IOException e) { - throw new SkipException("WARNING: IOException occurred: " + e + ", Skipping testDumpDirNotWritable test."); - } - if (!fs.supportsFileAttributeView(PosixFileAttributeView.class)) { - // No easy way to setup readonly directory without POSIX - throw new SkipException("WARNING: POSIX is not supported. Skipping testDumpDirNotWritable test."); + Assumptions.assumeTrue(false, "WARNING: IOException occurred: " + e + ", Skipping testDumpDirNotWritable test."); + return; } + Assumptions.assumeFalse(!fs.supportsFileAttributeView(PosixFileAttributeView.class), "WARNING: POSIX is not supported. Skipping testDumpDirNotWritable test."); // No easy way to setup readonly directory without POSIX Path testDir = Path.of("readOnly"); Path dumpDir = testDir.resolve(DUMP_LAMBDA_PROXY_CLASS_FILES); @@ -221,11 +217,8 @@ public class LogGeneratedClassesTest { Files.createDirectory(dumpDir, asFileAttribute(fromString("r-xr-xr-x"))); try { - if (isWriteableDirectory(dumpDir)) { - // Skipping the test: it's allowed to write into read-only directory - // (e.g. current user is super user). - throw new SkipException("WARNING: The dump directory is writeable. Skipping testDumpDirNotWritable test."); - } + Assumptions.assumeFalse(isWriteableDirectory(dumpDir), "WARNING: The dump directory is writeable. Skipping testDumpDirNotWritable test."); // Skipping the test: it's allowed to write into read-only directory + // (e.g. current user is super user). ProcessBuilder pb = createLimitedTestJavaProcessBuilder( "-cp", CLASSES.toString(), @@ -251,10 +244,9 @@ public class LogGeneratedClassesTest { longFQCN).directory(testDir.toFile()); OutputAnalyzer outputAnalyzer = executeProcess(pb); outputAnalyzer.shouldHaveExitValue(0); - assertEquals(outputAnalyzer.asLines().stream() - .filter(s -> s.startsWith("WARNING: Exception")) - .count(), - 2, "show error each capture"); + assertEquals(2, outputAnalyzer.asLines().stream() + .filter(s -> s.startsWith("WARNING: Exception")) + .count(), "show error each capture"); // dumpLong/DUMP_LAMBDA_PROXY_CLASS_FILES/com/example/nonsense/nonsense Path dumpPath = dumpDir.resolve("com/example/nonsense"); Predicate filter = p -> p.getParent() == null || dumpPath.startsWith(p) || p.startsWith(dumpPath); @@ -269,8 +261,8 @@ public class LogGeneratedClassesTest { } }); } - assertEquals(Files.walk(dumpDir) + assertEquals(5, Files.walk(dumpDir) .filter(filter) - .count(), 5, "Two lambda captured failed to log"); + .count(), "Two lambda captured failed to log"); } } diff --git a/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java b/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java index bf1db0f822e..4b74d05f270 100644 --- a/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java +++ b/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -24,22 +24,22 @@ /* * @test * @bug 8274848 - * @run testng InvokeSpecialMethodTest + * @run junit InvokeSpecialMethodTest * @summary ensure REF_invokeSpecial on a non-private implementation method * behaves as if `super::m` is invoked regardless of its access flag */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.CallSite; import java.lang.invoke.LambdaMetafactory; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + import static java.lang.invoke.MethodType.methodType; +import static org.junit.jupiter.api.Assertions.assertEquals; public class InvokeSpecialMethodTest { static class MethodTest { @@ -95,8 +95,7 @@ public class InvokeSpecialMethodTest { String get(); } - @DataProvider - public Object[][] methodProvider() { + public static Object[][] methodProvider() { return new Object[][]{ {MethodTest.M_PUBLIC, "test_public"}, {MethodTest.M_PROTECTED, "test_protected"}, @@ -104,7 +103,8 @@ public class InvokeSpecialMethodTest { }; } - @Test(dataProvider = "methodProvider") + @ParameterizedTest + @MethodSource("methodProvider") void test(MethodHandle implMethod, String expected) throws Throwable { testMetafactory(implMethod, expected); testAltMetafactory(implMethod, expected); @@ -117,7 +117,7 @@ public class InvokeSpecialMethodTest { MethodTest o = new MethodTest.SubClass(); StringFactory factory = (StringFactory) cs.dynamicInvoker().invokeExact(o); String actual = factory.get(); - Assert.assertEquals(actual, expected); + assertEquals(expected, actual); } static void testAltMetafactory(MethodHandle implMethod, String expected) throws Throwable { @@ -128,6 +128,6 @@ public class InvokeSpecialMethodTest { MethodTest o = new MethodTest.SubClass(); StringFactory factory = (StringFactory) cs.dynamicInvoker().invokeExact(o); String actual = factory.get(); - Assert.assertEquals(actual, expected); + assertEquals(expected, actual); } } diff --git a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java index a5cf6f68c50..fc730d790ac 100644 --- a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java +++ b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -28,7 +28,7 @@ * @library /test/lib * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm InheritedProtectedMethod + * @run junit/othervm InheritedProtectedMethod * @summary Test method reference to a method inherited from its * superclass in a different package. Such method's modifier * is changed from public to protected. @@ -37,10 +37,6 @@ import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.io.IOException; import java.lang.reflect.Method; import java.net.URL; @@ -48,13 +44,15 @@ import java.net.URLClassLoader; import java.nio.file.Path; import java.nio.file.Paths; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class InheritedProtectedMethod { private static final Path SRC_DIR = Paths.get(Utils.TEST_SRC, "src"); private static final Path CLASSES_DIR = Paths.get("classes"); - @BeforeTest + @BeforeAll static void setup() throws IOException { assertTrue(CompilerUtils.compile(SRC_DIR, CLASSES_DIR)); @@ -64,13 +62,13 @@ public class InheritedProtectedMethod { } @Test - public static void run() throws Exception { + public void run() throws Exception { URLClassLoader loader = new URLClassLoader("loader", new URL[]{ CLASSES_DIR.toUri().toURL()}, ClassLoader.getPlatformClassLoader()); Class methodInvokeClass = Class.forName("MethodInvoker", false, loader); Method invokeMethod = methodInvokeClass.getMethod("invoke"); String result = (String)invokeMethod.invoke(null); - assertEquals(result, "protected inherited method"); + assertEquals("protected inherited method", result); } } diff --git a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java index 666ba5c254b..980114149a8 100644 --- a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java +++ b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -24,7 +24,7 @@ /* * @test * @bug 8227415 8254975 8270056 - * @run testng/othervm p.ProtectedMethodInOtherPackage + * @run junit/othervm p.ProtectedMethodInOtherPackage * @summary method reference to a protected method inherited from its * superclass in a different runtime package where * lambda proxy class has no access to it. @@ -47,12 +47,12 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.util.function.Function; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ProtectedMethodInOtherPackage { @Test - public static void remotePackageSameLoader() { + public void remotePackageSameLoader() { Sub_I sub = new Sub_I(); sub.test(Paths.get("test")); } @@ -76,14 +76,14 @@ public class ProtectedMethodInOtherPackage { } @Test - public static void splitPackage() throws Throwable { + public void splitPackage() throws Throwable { ClassLoader parent = new Loader("loader-A", null, A.class); ClassLoader loader = new Loader("loader-B", parent, B.class); Class aClass = Class.forName(A.class.getName(), false, loader); Class bClass = Class.forName(B.class.getName(), false, loader); - assertTrue(aClass.getClassLoader() == parent); - assertTrue(bClass.getClassLoader() == loader); - assertEquals(aClass.getPackageName(), bClass.getPackageName()); + assertSame(parent, aClass.getClassLoader()); + assertSame(loader, bClass.getClassLoader()); + assertEquals(bClass.getPackageName(), aClass.getPackageName()); Object b = bClass.getDeclaredConstructor().newInstance(); @@ -102,14 +102,14 @@ public class ProtectedMethodInOtherPackage { } @Test - public static void protectedStaticMethodInSplitPackage() throws Throwable { + public void protectedStaticMethodInSplitPackage() throws Throwable { ClassLoader parent = new Loader("loader-A1", null, A1.class); ClassLoader loader = new Loader("loader-B1", parent, B1.class); Class aClass1 = Class.forName(A1.class.getName(), false, loader); Class bClass1 = Class.forName(B1.class.getName(), false, loader); - assertTrue(aClass1.getClassLoader() == parent); - assertTrue(bClass1.getClassLoader() == loader); - assertEquals(aClass1.getPackageName(), bClass1.getPackageName()); + assertSame(parent, aClass1.getClassLoader()); + assertSame(loader, bClass1.getClassLoader()); + assertEquals(bClass1.getPackageName(), aClass1.getPackageName()); // verify subclass can access a static protected method inherited from // its superclass in a split package diff --git a/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java b/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java index 0e81c6a9eec..15a46e6ca2c 100644 --- a/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java +++ b/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, 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 @@ -24,7 +24,7 @@ /* * @test * @bug 8013527 - * @run testng/othervm ChainedLookupTest + * @run junit/othervm ChainedLookupTest * @summary Test MethodHandles.lookup method to produce the Lookup object with * proper lookup class if invoked through reflection and method handle. */ @@ -33,11 +33,11 @@ import java.lang.invoke.*; import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Method; -import org.testng.annotations.Test; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ChainedLookupTest { /** @@ -121,7 +121,7 @@ public class ChainedLookupTest { } void test(Lookup lookup, String msg) throws Throwable { - assertTrue(lookup.lookupClass() == ChainedLookupTest.class); + assertSame(ChainedLookupTest.class, lookup.lookupClass()); assertTrue(lookup.hasFullPrivilegeAccess()); MethodHandle mh = lookup.findStatic(lookup.lookupClass(), "say", methodType(void.class, String.class)); diff --git a/test/jdk/java/lang/invoke/lookup/LookupClassTest.java b/test/jdk/java/lang/invoke/lookup/LookupClassTest.java index 205bd3d893e..5970d0331dd 100644 --- a/test/jdk/java/lang/invoke/lookup/LookupClassTest.java +++ b/test/jdk/java/lang/invoke/lookup/LookupClassTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -25,44 +25,44 @@ * @test * @bug 8173975 * @summary Lookup::in throws IAE if the target class is a primitive class or array class - * @run testng/othervm LookupClassTest + * @run junit/othervm LookupClassTest */ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LookupClassTest { private static final LookupClassTest[] ARRAY = new LookupClassTest[0]; - @BeforeTest - public void test() { + @BeforeAll + public static void test() { assertTrue(ARRAY.getClass().isArray()); assertSamePackage(MethodHandles.lookup(), ARRAY.getClass()); assertSamePackage(MethodHandles.publicLookup(), int.class); } - private void assertSamePackage(Lookup lookup, Class targetClass) { - assertEquals(lookup.lookupClass().getPackageName(), targetClass.getPackageName()); + private static void assertSamePackage(Lookup lookup, Class targetClass) { + assertEquals(targetClass.getPackageName(), lookup.lookupClass().getPackageName()); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void arrayLookupClass() { Lookup lookup = MethodHandles.lookup(); - lookup.in(ARRAY.getClass()); + assertThrows(IllegalArgumentException.class, () -> lookup.in(ARRAY.getClass())); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void primitiveLookupClass() { Lookup lookup = MethodHandles.publicLookup(); - lookup.in(int.class); + assertThrows(IllegalArgumentException.class, () -> lookup.in(int.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void voidLookupClass() { Lookup lookup = MethodHandles.publicLookup(); - lookup.in(void.class); + assertThrows(IllegalArgumentException.class, () -> lookup.in(void.class)); } } diff --git a/test/jdk/java/lang/invoke/lookup/SpecialStatic.java b/test/jdk/java/lang/invoke/lookup/SpecialStatic.java index 31ded727d66..3ff99b9dfda 100644 --- a/test/jdk/java/lang/invoke/lookup/SpecialStatic.java +++ b/test/jdk/java/lang/invoke/lookup/SpecialStatic.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2025, 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 @@ -25,7 +25,7 @@ * @bug 8032400 * @summary JSR292: invokeSpecial: InternalError attempting to lookup a method * @compile -XDignore.symbol.file SpecialStatic.java - * @run testng test.java.lang.invoke.lookup.SpecialStatic + * @run junit test.java.lang.invoke.lookup.SpecialStatic */ package test.java.lang.invoke.lookup; @@ -38,13 +38,13 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.AccessFlag; -import org.testng.annotations.*; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; import static java.lang.constant.ConstantDescs.*; import static java.lang.constant.DirectMethodHandleDesc.Kind.SPECIAL; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** * Test case: @@ -105,7 +105,7 @@ public class SpecialStatic { public void testConstant() throws Throwable { MethodHandle mh = (MethodHandle)t3.getDeclaredMethod("getMethodHandle").invoke(null); int result = (int)mh.invoke(t3.newInstance()); - assertEquals(result, 1); // T1.m should be invoked. + assertEquals(1, result); // T1.m should be invoked. } @Test @@ -113,7 +113,7 @@ public class SpecialStatic { MethodHandles.Lookup lookup = (MethodHandles.Lookup)t3.getDeclaredMethod("getLookup").invoke(null); MethodHandle mh = lookup.findSpecial(t1, "m", MethodType.methodType(int.class), t3); int result = (int)mh.invoke(t3.newInstance()); - assertEquals(result, 1); // T1.m should be invoked. + assertEquals(1, result); // T1.m should be invoked. } public static byte[] dumpT1() { diff --git a/test/jdk/java/lang/invoke/modules/Driver.java b/test/jdk/java/lang/invoke/modules/Driver.java index 5c00de3ad47..11c44280309 100644 --- a/test/jdk/java/lang/invoke/modules/Driver.java +++ b/test/jdk/java/lang/invoke/modules/Driver.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, 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 @@ -21,9 +21,9 @@ * questions. */ -/** +/* * @test * @build m1/* m2/* Unnamed - * @run testng/othervm m1/p1.Main + * @run junit/othervm m1/p1.Main * @summary Basic test case for module access checks and Lookup.in. */ diff --git a/test/jdk/java/lang/invoke/modules/Driver1.java b/test/jdk/java/lang/invoke/modules/Driver1.java index 654ee04c9e0..4ef7130ff94 100644 --- a/test/jdk/java/lang/invoke/modules/Driver1.java +++ b/test/jdk/java/lang/invoke/modules/Driver1.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -21,11 +21,11 @@ * questions. */ -/** +/* * @test * @bug 8173978 * @build m3/* m4/* m5/* Unnamed Unnamed1 - * @run testng/othervm m3/jdk.test.ModuleAccessTest + * @run junit/othervm m3/jdk.test.ModuleAccessTest * @summary Basic test case for module access checks and Lookup.in and * MethodHandles.privateLookupIn */ diff --git a/test/jdk/java/lang/invoke/modules/m1/module-info.java b/test/jdk/java/lang/invoke/modules/m1/module-info.java index db03841b4d0..ecd133ae6a1 100644 --- a/test/jdk/java/lang/invoke/modules/m1/module-info.java +++ b/test/jdk/java/lang/invoke/modules/m1/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -22,6 +22,6 @@ */ module m1 { requires m2; - requires org.testng; + requires org.junit.platform.console.standalone; exports p1; } diff --git a/test/jdk/java/lang/invoke/modules/m1/p1/Main.java b/test/jdk/java/lang/invoke/modules/m1/p1/Main.java index 0a4d2fff1db..5a2a7c91999 100644 --- a/test/jdk/java/lang/invoke/modules/m1/p1/Main.java +++ b/test/jdk/java/lang/invoke/modules/m1/p1/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, 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 @@ -30,26 +30,24 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /** * Basic test case for module access checks and Lookup.in. */ - -@Test public class Main { - private Class p1_Type1; // m1, exported - private Class p2_Type2; // m1, not exported - private Class q1_Type1; // m2, exported - private Class q2_Type2; // m2, not exported - private Class signalClass; // java.base, not exported - private Class unnamedClass; // class in unnamed module + private static Class p1_Type1; // m1, exported + private static Class p2_Type2; // m1, not exported + private static Class q1_Type1; // m2, exported + private static Class q2_Type2; // m2, not exported + private static Class signalClass; // java.base, not exported + private static Class unnamedClass; // class in unnamed module - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { try { p1_Type1 = Class.forName("p1.Type1"); p2_Type2 = Class.forName("p2.Type2"); @@ -64,15 +62,15 @@ public class Main { // check setup Module m1 = ModuleLayer.boot().findModule("m1").orElse(null); assertNotNull(m1); - assertTrue(p1_Type1.getModule() == m1); - assertTrue(p2_Type2.getModule() == m1); + assertSame(m1, p1_Type1.getModule()); + assertSame(m1, p2_Type2.getModule()); assertTrue(m1.isExported("p1")); assertFalse(m1.isExported("p2")); Module m2 = ModuleLayer.boot().findModule("m2").orElse(null); assertNotNull(m2); - assertTrue(q1_Type1.getModule() == m2); - assertTrue(q2_Type2.getModule() == m2); + assertSame(m2, q1_Type1.getModule()); + assertSame(m2, q2_Type2.getModule()); assertTrue(m2.isExported("q1")); assertFalse(m2.isExported("q2")); @@ -91,9 +89,10 @@ public class Main { * [A2] can access public types in packages exported by modules that m1 reads * [A3] cannot access public types in non-exported modules of modules that m1 reads */ + @Test public void testLookup() throws Exception { Lookup lookup = MethodHandles.lookup(); - assertTrue((lookup.lookupModes() & MODULE) == MODULE); // [A0] + assertEquals(MODULE, lookup.lookupModes() & MODULE); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); // [A1] @@ -116,9 +115,10 @@ public class Main { * * [A0] module and public access is not lost */ + @Test public void testToSameModule() throws Exception { Lookup lookup = MethodHandles.lookup().in(p2_Type2); - assertTrue(lookup.lookupModes() == (MODULE|PUBLIC)); // [A0] + assertEquals(MODULE | PUBLIC, lookup.lookupModes()); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); @@ -142,15 +142,16 @@ public class Main { * [A0] has PUBLIC access if accessible; otherwise no access * [A1] old lookup class becomes previous lookup class */ + @Test public void testFromNamedToNamedModule() throws Exception { // m2/q1_Type1 is accessible to m1 whereas m2/q_Type2 is not accessible Lookup lookup = MethodHandles.lookup().in(q1_Type1); - assertTrue(lookup.lookupModes() == PUBLIC); // [A0] - assertTrue(lookup.previousLookupClass() == Main.class); // [A1] + assertEquals(PUBLIC, lookup.lookupModes()); // [A0] + assertSame(Main.class, lookup.previousLookupClass()); // [A1] Lookup lookup2 = MethodHandles.lookup().in(q2_Type2); - assertTrue(lookup2.lookupModes() == 0); // [A0] - assertTrue(lookup2.previousLookupClass() == Main.class); // [A1] + assertEquals(0, lookup2.lookupModes()); // [A0] + assertSame(Main.class, lookup2.previousLookupClass()); // [A1] // m1 findConstructorExpectingIAE(lookup, p1_Type1, void.class); @@ -185,9 +186,10 @@ public class Main { * * [A0] has PUBLIC access */ + @Test public void testFromNamedToUnnamedModule() throws Exception { Lookup lookup = MethodHandles.lookup().in(unnamedClass); - assertTrue(lookup.lookupModes() == PUBLIC); // [A0] + assertEquals(PUBLIC, lookup.lookupModes()); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); // p1 is exported @@ -210,10 +212,11 @@ public class Main { * * [A0] retains PUBLIC access */ + @Test public void testFromUnnamedToNamedModule() throws Exception { Lookup lookup = MethodHandles.lookup(); lookup = MethodHandles.privateLookupIn(unnamedClass, lookup).in(p1_Type1); - assertTrue(lookup.lookupModes() == PUBLIC); // A0 + assertEquals(PUBLIC, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -236,9 +239,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookup() throws Exception { Lookup lookup = MethodHandles.publicLookup(); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -261,9 +265,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToBaseModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(String.class); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -287,9 +292,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToAccessibleTypeInNamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(p1_Type1); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -312,9 +318,10 @@ public class Main { * * [A0] has no access */ + @Test public void testPublicLookupToInaccessibleTypeInNamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(p2_Type2); - assertTrue(lookup.lookupModes() == 0); // A0 + assertEquals(0, lookup.lookupModes()); // A0 // m1 findConstructorExpectingIAE(lookup, p1_Type1, void.class); @@ -337,9 +344,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToUnnamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(unnamedClass); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -366,10 +374,7 @@ public class Main { Class clazz, Class rtype, Class... ptypes) throws Exception { - try { - findConstructor(lookup, clazz, rtype, ptypes); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> findConstructor(lookup, clazz, rtype, ptypes)); } /** diff --git a/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java b/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java index 6a1e8efe103..235c712926d 100644 --- a/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java +++ b/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -23,15 +23,12 @@ package jdk.test; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; +import java.lang.management.ThreadMXBean; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; @@ -42,7 +39,11 @@ import java.util.stream.Stream; import e1.CrackM5Access; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ModuleAccessTest { static ModuleLookup m3; @@ -55,8 +56,8 @@ public class ModuleAccessTest { static Class unnamed; static Class unnamed1; - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { m3 = new ModuleLookup("m3", 'C'); m4 = new ModuleLookup("m4", 'D'); m5 = new ModuleLookup("m5", 'E'); @@ -76,8 +77,7 @@ public class ModuleAccessTest { CrackM5Access.addReads(unnamed.getModule()); } - @DataProvider(name = "samePackage") - public Object[][] samePackage() throws Exception { + public static Object[][] samePackage() throws Exception { return new Object[][] { { m3.lookup, m3.type2 }, { privLookupIn, m3.type1 }, @@ -93,7 +93,8 @@ public class ModuleAccessTest { * [A1] no change in previous lookup class * [A2] PROTECTED, PRIVATE and ORIGINAL are dropped */ - @Test(dataProvider = "samePackage") + @ParameterizedTest + @MethodSource("samePackage") public void testLookupInSamePackage(Lookup lookup, Class targetClass) throws Exception { Class lookupClass = lookup.lookupClass(); Lookup lookup2 = lookup.in(targetClass); @@ -105,8 +106,7 @@ public class ModuleAccessTest { assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|ORIGINAL))); // [A2] } - @DataProvider(name = "sameModule") - public Object[][] sameModule() throws Exception { + public static Object[][] sameModule() throws Exception { return new Object[][] { { m3.lookup, m3.type3}, { privLookupIn, m3.type3}, @@ -121,20 +121,20 @@ public class ModuleAccessTest { * [A1] no change in previous lookup class * [A2] PROTECTED, PRIVATE, PACKAGE and ORIGINAL are dropped */ - @Test(dataProvider = "sameModule") + @ParameterizedTest + @MethodSource("sameModule") public void testLookupInSameModule(Lookup lookup, Class targetClass) throws Exception { Class lookupClass = lookup.lookupClass(); Lookup lookup2 = lookup.in(targetClass); - assertTrue(lookupClass.getPackage() != targetClass.getPackage()); - assertTrue(lookupClass.getModule() == targetClass.getModule()); - assertTrue(lookup2.lookupClass() == targetClass); // [A0] - assertTrue(lookup2.previousLookupClass() == lookup.previousLookupClass()); // [A1] - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|ORIGINAL))); // [A2] + assertNotSame(targetClass.getPackage(), lookupClass.getPackage()); + assertSame(targetClass.getModule(), lookupClass.getModule()); + assertSame(targetClass, lookup2.lookupClass()); // [A0] + assertSame(lookup.previousLookupClass(), lookup2.previousLookupClass()); // [A1] + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | ORIGINAL), lookup2.lookupModes()); // [A2] } - @DataProvider(name = "anotherModule") - public Object[][] anotherModule() throws Exception { + public static Object[][] anotherModule() throws Exception { return new Object[][] { { m3.lookup, m4.type1, m5, m5.accessibleTypesTo(m3.module, m4.module) }, { m4.lookup, m5.type2, m3, m3.accessibleTypesTo(m4.module, m5.module) }, @@ -154,21 +154,22 @@ public class ModuleAccessTest { * [A5] can access public types in m1 exported to m0 * [A6] can access public types in m2 exported to m0 and m1 */ - @Test(dataProvider = "anotherModule") + @ParameterizedTest + @MethodSource("anotherModule") public void testLookupInAnotherModule(Lookup lookup, Class targetClass, ModuleLookup m2, Set> otherTypes) throws Exception { Class lookupClass = lookup.lookupClass(); Module m0 = lookupClass.getModule(); Module m1 = targetClass.getModule(); - assertTrue(m0 != m1); + assertNotSame(m1, m0); assertTrue(m0.canRead(m1)); assertTrue(m1.isExported(targetClass.getPackageName(), m0)); Lookup lookup2 = lookup.in(targetClass); - assertTrue(lookup2.lookupClass() == targetClass); // [A0] - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); // [A1] - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|MODULE|ORIGINAL))); // [A2] + assertSame(targetClass, lookup2.lookupClass()); // [A0] + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); // [A1] + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | MODULE | ORIGINAL), lookup2.lookupModes()); // [A2] // [A3] no access to module internal type in m0 // [A4] if m1 reads m0, @@ -207,7 +208,7 @@ public class ModuleAccessTest { // [A5] can access public types exported from m2 unconditionally // [A5] can access public types exported from m2 to m0 and m1 for (Class type : otherTypes) { - assertTrue(type.getModule() == m2.module); + assertSame(m2.module, type.getModule()); testAccess(lookup2, type); } @@ -215,10 +216,7 @@ public class ModuleAccessTest { for (Class type : Set.of(m2.type1, m2.type2, m2.type3)) { if (!otherTypes.contains(type)) { // type is accessible to this lookup - try { - lookup2.accessClass(type); - assertTrue(false); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> lookup2.accessClass(type)); findConstructorExpectingIAE(lookup2, type, void.class); } @@ -227,7 +225,7 @@ public class ModuleAccessTest { public void testAccess(Lookup lookup, Class type) throws Exception { // type is accessible to this lookup - assertTrue(lookup.accessClass(type) == type); + assertSame(type, lookup.accessClass(type)); // can find constructor findConstructor(lookup, type, void.class); @@ -237,28 +235,27 @@ public class ModuleAccessTest { Module m2 = type.getModule(); assertTrue(m0 != m1 && m0 != null); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertEquals(0, lookup.lookupModes() & MODULE); assertTrue(m0 != m2 || m1 != m2); MethodHandles.Lookup lookup2 = lookup.in(type); if (m2 == m1) { // the same module of the lookup class - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.previousLookupClass()); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.previousLookupClass(), lookup2.previousLookupClass()); } else if (m2 == m0) { // hop back to the module of the previous lookup class - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); } else { // hop to a third module - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); - assertTrue(lookup2.lookupModes() == 0); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); + assertEquals(0, lookup2.lookupModes()); } } - @DataProvider(name = "thirdModule") - public Object[][] thirdModule() throws Exception { + public static Object[][] thirdModule() throws Exception { return new Object[][] { { m3.lookup, m4.type1, m5.type1}, { m3.lookup, m4.type2, m5.type1}, @@ -273,7 +270,8 @@ public class ModuleAccessTest { * [A1] c1 becomes previous lookup class * [A2] all access bits are dropped */ - @Test(dataProvider = "thirdModule") + @ParameterizedTest + @MethodSource("thirdModule") public void testLookupInThirdModule(Lookup lookup, Class c1, Class c2) throws Exception { Class c0 = lookup.lookupClass(); Module m0 = c0.getModule(); @@ -287,18 +285,17 @@ public class ModuleAccessTest { assertTrue(m2.isExported(c2.getPackageName(), m0) && m2.isExported(c2.getPackageName(), m1)); Lookup lookup1 = lookup.in(c1); - assertTrue(lookup1.lookupClass() == c1); - assertTrue(lookup1.previousLookupClass() == c0); - assertTrue(lookup1.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|MODULE|ORIGINAL))); + assertSame(c1, lookup1.lookupClass()); + assertSame(c0, lookup1.previousLookupClass()); + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | MODULE | ORIGINAL), lookup1.lookupModes()); Lookup lookup2 = lookup1.in(c2); - assertTrue(lookup2.lookupClass() == c2); // [A0] - assertTrue(lookup2.previousLookupClass() == c1); // [A1] - assertTrue(lookup2.lookupModes() == 0, lookup2.toString()); // [A2] + assertSame(c2, lookup2.lookupClass()); // [A0] + assertSame(c1, lookup2.previousLookupClass()); // [A1] + assertEquals(0, lookup2.lookupModes(), lookup2.toString()); // [A2] } - @DataProvider(name = "privLookupIn") - public Object[][] privLookupIn() throws Exception { + public static Object[][] privLookupIn() throws Exception { return new Object[][] { { m3.lookup, m4.type1 }, { m3.lookup, m5.type1 }, @@ -316,24 +313,22 @@ public class ModuleAccessTest { * [A2] the lookup class becomes previous lookup class * [A3] IAE thrown if lookup has no MODULE access */ - @Test(dataProvider = "privLookupIn") + @ParameterizedTest + @MethodSource("privLookupIn") public void testPrivateLookupIn(Lookup lookup, Class targetClass) throws Exception { Module m0 = lookup.lookupClass().getModule(); Module m1 = targetClass.getModule(); // privateLookupIn from m0 to m1 - assertTrue(m0 != m1); + assertNotSame(m1, m0); assertTrue(m1.isOpen(targetClass.getPackageName(), m0)); Lookup privLookup1 = MethodHandles.privateLookupIn(targetClass, lookup); - assertTrue(privLookup1.lookupModes() == (PROTECTED|PRIVATE|PACKAGE|PUBLIC)); // [A0] - assertTrue(privLookup1.lookupClass() == targetClass); // [A1] - assertTrue(privLookup1.previousLookupClass() == lookup.lookupClass()); // [A2] + assertEquals(PROTECTED | PRIVATE | PACKAGE | PUBLIC, privLookup1.lookupModes()); // [A0] + assertSame(targetClass, privLookup1.lookupClass()); // [A1] + assertSame(lookup.lookupClass(), privLookup1.previousLookupClass()); // [A2] // privLookup1 has no MODULE access; can't do privateLookupIn - try { - Lookup privLookup2 = MethodHandles.privateLookupIn(targetClass, privLookup1); // [A3] - assertFalse(privLookup2 != null); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(targetClass, privLookup1)); // [A3] } /** @@ -343,9 +338,9 @@ public class ModuleAccessTest { public void testPrivateLookupAccess() throws Exception { Class staticsClass = e1.Statics.class; Lookup privLookup1 = MethodHandles.privateLookupIn(staticsClass, m4.lookup); - assertTrue((privLookup1.lookupModes() & MODULE) == 0); - assertTrue(privLookup1.lookupClass() == staticsClass); - assertTrue(privLookup1.previousLookupClass() == m4.lookup.lookupClass()); + assertEquals(0, (privLookup1.lookupModes() & MODULE)); + assertSame(staticsClass, privLookup1.lookupClass()); + assertSame(m4.lookup.lookupClass(), privLookup1.previousLookupClass()); // access private member and default package member in m5 MethodType mtype = MethodType.methodType(void.class); @@ -365,12 +360,9 @@ public class ModuleAccessTest { // lose private access Lookup privLookup2 = MethodHandles.privateLookupIn(m5.type1, m4.lookup); Lookup lookup = privLookup2.in(staticsClass); - assertTrue((lookup.lookupModes() & PRIVATE) == 0); + assertEquals(0, lookup.lookupModes() & PRIVATE); MethodHandle mh3 = lookup.findStatic(staticsClass, "packageMethod", mtype); - try { - lookup.findStatic(staticsClass, "privateMethod", mtype); - assertTrue(false); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> lookup.findStatic(staticsClass, "privateMethod", mtype)); } /** @@ -380,16 +372,16 @@ public class ModuleAccessTest { @Test public void testDropLookupMode() throws Exception { Lookup lookup = MethodHandles.privateLookupIn(m5.type1, m4.lookup); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertEquals(0, lookup.lookupModes() & MODULE); Lookup lookup1 = lookup.dropLookupMode(PRIVATE); - assertTrue(lookup1.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE))); + assertEquals(lookup1.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE)); Lookup lookup2 = lookup.dropLookupMode(PACKAGE); - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE))); + assertEquals(lookup2.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE)); Lookup lookup3 = lookup.dropLookupMode(MODULE); - assertTrue(lookup3.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE))); + assertEquals(lookup3.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE)); Lookup lookup4 = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup4.lookupModes() == 0); + assertEquals(0, lookup4.lookupModes()); } @@ -406,11 +398,8 @@ public class ModuleAccessTest { // drop MODULE access i.e. only PUBLIC access Lookup lookup = privLookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupModes() == PUBLIC); - try { - MethodHandle mh2 = lookup.findStatic(nonPUblicType, "publicStatic", mtype); - assertFalse(mh2 != null); - } catch (IllegalAccessException e) {} + assertEquals(PUBLIC, lookup.lookupModes()); + assertThrows(IllegalAccessException.class, () -> lookup.findStatic(nonPUblicType, "publicStatic", mtype)); } @Test @@ -421,21 +410,18 @@ public class ModuleAccessTest { Lookup pub3 = pub2.in(java.lang.management.ThreadMXBean.class); Lookup pub4 = pub3.dropLookupMode(UNCONDITIONAL); - assertTrue(publicLookup.lookupClass() == Object.class); - assertTrue(publicLookup.lookupModes() == UNCONDITIONAL); - assertTrue(pub1.lookupClass() == m3.type1); - assertTrue(pub1.lookupModes() == UNCONDITIONAL); - assertTrue(pub2.lookupClass() == String.class); - assertTrue(pub2.lookupModes() == UNCONDITIONAL); - assertTrue(pub3.lookupClass() == java.lang.management.ThreadMXBean.class); - assertTrue(pub3.lookupModes() == UNCONDITIONAL); - assertTrue(pub4.lookupModes() == 0); + assertSame(Object.class, publicLookup.lookupClass()); + assertEquals(UNCONDITIONAL, publicLookup.lookupModes()); + assertSame(m3.type1, pub1.lookupClass()); + assertEquals(UNCONDITIONAL, pub1.lookupModes()); + assertSame(String.class, pub2.lookupClass()); + assertEquals(UNCONDITIONAL, pub2.lookupModes()); + assertSame(ThreadMXBean.class, pub3.lookupClass()); + assertEquals(UNCONDITIONAL, pub3.lookupModes()); + assertEquals(0, pub4.lookupModes()); // publicLookup has no MODULE access; can't do privateLookupIn - try { - Lookup pub5 = MethodHandles.privateLookupIn(m4.type1, pub1); - assertFalse(pub5 != null); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(m4.type1, pub1)); } static class ModuleLookup { @@ -548,10 +534,7 @@ public class ModuleAccessTest { Class clazz, Class rtype, Class... ptypes) throws Exception { - try { - MethodHandle mh = findConstructor(lookup, clazz, rtype, ptypes); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> findConstructor(lookup, clazz, rtype, ptypes)); } /** diff --git a/test/jdk/java/lang/invoke/modules/m3/module-info.java b/test/jdk/java/lang/invoke/modules/m3/module-info.java index 1f47c42c196..c9d8fab20a5 100644 --- a/test/jdk/java/lang/invoke/modules/m3/module-info.java +++ b/test/jdk/java/lang/invoke/modules/m3/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, 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 @@ -24,7 +24,7 @@ module m3 { requires m4; requires m5; - requires org.testng; + requires org.junit.platform.console.standalone; requires java.management; exports c1; opens c2 to m5; From 2c3ad0f425c75332412a5e8e5733dd0d073a09c8 Mon Sep 17 00:00:00 2001 From: Cesar Soares Lucas Date: Fri, 23 Jan 2026 17:56:04 +0000 Subject: [PATCH 024/105] 8373021: aarch64: MacroAssembler::arrays_equals reads out of bounds Reviewed-by: rkennke, aph --- src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp index b8a9afc123f..27428a5c558 100644 --- a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp @@ -5782,6 +5782,9 @@ address MacroAssembler::arrays_equals(Register a1, Register a2, Register tmp3, // return false; bind(A_IS_NOT_NULL); ldrw(cnt1, Address(a1, length_offset)); + ldrw(tmp5, Address(a2, length_offset)); + cmp(cnt1, tmp5); + br(NE, DONE); // If lengths differ, return false // Increase loop counter by diff between base- and actual start-offset. addw(cnt1, cnt1, extra_length); lea(a1, Address(a1, start_offset)); @@ -5848,6 +5851,9 @@ address MacroAssembler::arrays_equals(Register a1, Register a2, Register tmp3, cbz(a1, DONE); ldrw(cnt1, Address(a1, length_offset)); cbz(a2, DONE); + ldrw(tmp5, Address(a2, length_offset)); + cmp(cnt1, tmp5); + br(NE, DONE); // If lengths differ, return false // Increase loop counter by diff between base- and actual start-offset. addw(cnt1, cnt1, extra_length); From e08fb3a914ac348dc691ae3fc46c6bdbc34faf46 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Fri, 23 Jan 2026 18:19:23 +0000 Subject: [PATCH 025/105] 8375221: Update code to get PrinterResolution from CUPS/IPP print service Reviewed-by: serb, psadhukhan --- .../classes/sun/print/AttributeClass.java | 24 +++++++ .../classes/sun/print/IPPPrintService.java | 67 ++++++++++--------- .../unix/native/common/awt/CUPSfuncs.c | 57 +++++++++++++++- test/jdk/javax/print/PrintablePrintDPI.java | 8 ++- 4 files changed, 120 insertions(+), 36 deletions(-) diff --git a/src/java.desktop/unix/classes/sun/print/AttributeClass.java b/src/java.desktop/unix/classes/sun/print/AttributeClass.java index 10d0714a059..3db6e310dd2 100644 --- a/src/java.desktop/unix/classes/sun/print/AttributeClass.java +++ b/src/java.desktop/unix/classes/sun/print/AttributeClass.java @@ -174,6 +174,30 @@ public final class AttributeClass { } + /** + * Returns 3 int values. + * xres, yres, resolution as either dpi or dpcm + * The resolution is just a single byte of data. + */ + public int[] getIntResolutionValue() { + int[] res = {0, 0, 0}; + byte[] bufArray = (byte[])myValue; + if (bufArray != null) { + int nBytes = 4; // 32-bit signed integer + for (int j=0; j<2; j++) { // 2 set of integers + byte[] intBytes = new byte[nBytes]; + // REMIND: # bytes should be 8 + for (int i=0; i< nBytes; i++) { + //+ 1 because the 1st byte is length + intBytes[i] = bufArray[i+(4*j)+1]; + } + res[j] = convertToInt(intBytes); + } + res[2] = (int)bufArray[9]; + } + return res; + } + /** * Returns String value. */ diff --git a/src/java.desktop/unix/classes/sun/print/IPPPrintService.java b/src/java.desktop/unix/classes/sun/print/IPPPrintService.java index 2bf326fca57..8a3b872b107 100644 --- a/src/java.desktop/unix/classes/sun/print/IPPPrintService.java +++ b/src/java.desktop/unix/classes/sun/print/IPPPrintService.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2026, 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 @@ -141,7 +141,7 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService private MediaSizeName[] mediaSizeNames; private CustomMediaSizeName[] customMediaSizeNames; private int defaultMediaIndex; - private int[] rawResolutions = null; + private int[] ppdResolutions = null; private PrinterResolution[] printerResolutions = null; private boolean isCupsPrinter; private boolean init; @@ -205,8 +205,7 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService OrientationRequested.PORTRAIT, new PageRanges(1), //PresentationDirection, - // CUPS does not supply printer-resolution attribute - //new PrinterResolution(300, 300, PrinterResolution.DPI), + new PrinterResolution(300, 300, PrinterResolution.DPI), //PrintQuality.NORMAL, new RequestingUserName("", Locale.getDefault()), //SheetCollate.UNCOLLATED, //CUPS has no sheet collate? @@ -467,7 +466,9 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService : getSupportedOutputBins(); customMediaSizeNames = cps.getCustomMediaSizeNames(); defaultMediaIndex = cps.getDefaultMediaIndex(); - rawResolutions = cps.getRawResolutions(); + if (ppdResolutions == null) { + ppdResolutions = cps.getRawResolutions(); + } } urlConnection.disconnect(); init = true; @@ -821,14 +822,7 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService } } } else if (category == PrinterResolution.class) { - PrinterResolution[] supportedRes = getPrintResolutions(); - if (supportedRes == null) { - return null; - } - PrinterResolution []arr = - new PrinterResolution[supportedRes.length]; - System.arraycopy(supportedRes, 0, arr, 0, supportedRes.length); - return arr; + return getPrintResolutions(); } else if (category == OutputBin.class) { return Arrays.copyOf(outputBins, outputBins.length); } @@ -1137,8 +1131,6 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService catList.add(Chromaticity.class); } - // CUPS does not report printer resolution via IPP but it - // may be gleaned from the PPD. PrinterResolution[] supportedRes = getPrintResolutions(); if (supportedRes != null && (supportedRes.length > 0)) { catList.add(PrinterResolution.class); @@ -1264,7 +1256,6 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService } } - @Override public synchronized PrintServiceAttributeSet getAttributes() { if (!init) { @@ -1684,9 +1675,7 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService } else if (category == PrinterResolution.class) { PrinterResolution[] supportedRes = getPrintResolutions(); if ((supportedRes != null) && (supportedRes.length > 0)) { - return supportedRes[0]; - } else { - return new PrinterResolution(300, 300, PrinterResolution.DPI); + return supportedRes[0]; } } else if (category == OutputBin.class) { if (attribClass != null) { @@ -1697,26 +1686,40 @@ public final class IPPPrintService implements PrintService, SunPrinterJobService return null; } + /* Called only from contexts that have called initAttributes(). + * Try IPP first, and if that produces nothing, fall back to the PPD + */ private PrinterResolution[] getPrintResolutions() { + int[] rawResolutions = null; if (printerResolutions == null) { - if (rawResolutions == null) { - printerResolutions = new PrinterResolution[0]; - } else { - int numRes = rawResolutions.length / 2; - PrinterResolution[] pres = new PrinterResolution[numRes]; - for (int i=0; i < numRes; i++) { - pres[i] = new PrinterResolution(rawResolutions[i*2], - rawResolutions[i*2+1], - PrinterResolution.DPI); - } - printerResolutions = pres; + AttributeClass attribClass = (getAttMap != null) ? + getAttMap.get("printer-resolution-supported") + : null; + if (attribClass != null) { + rawResolutions = attribClass.getIntResolutionValue(); } + if (rawResolutions == null) { + rawResolutions = ppdResolutions; + } + if (rawResolutions == null) { + rawResolutions = new int[] { 300, 300, 3 } ; + } + int numRes = rawResolutions.length / 3; + PrinterResolution[] pres = new PrinterResolution[numRes]; + for (int i = 0; i < numRes; i++) { + int units = (rawResolutions[i*3+2] == 4) ? PrinterResolution.DPCM : PrinterResolution.DPI; + pres[i] = new PrinterResolution(rawResolutions[i*3], + rawResolutions[i*3+1], + units); + } + printerResolutions = pres; } - return printerResolutions; + return printerResolutions.clone(); } private boolean isSupportedResolution(PrinterResolution res) { - PrinterResolution[] supportedRes = getPrintResolutions(); + PrinterResolution[] supportedRes = + (PrinterResolution[])getSupportedAttributeValues(PrinterResolution.class, null, null); if (supportedRes != null) { for (int i=0; iNewObject(env, intCls, intCtr, 3); + CHECK_NULL(dpi); // NOTE: cupsGetPPD returns a pointer to a filename of a temporary file. // unlink() must be called to remove the file after using it. @@ -672,6 +691,7 @@ Java_sun_print_CUPSPrinter_getResolutions(JNIEnv *env, CHECK_NULL(ryObj); (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, rxObj); (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, ryObj); + (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, dpi); } for (i = 0; i < resolution->num_choices; i++) { @@ -700,6 +720,41 @@ Java_sun_print_CUPSPrinter_getResolutions(JNIEnv *env, CHECK_NULL(ryObj); (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, rxObj); (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, ryObj); + (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, dpi); + } + } + + } else { + ppd_attr_t *defresolution = j2d_ppdFindAttr(ppd, "DefaultResolution", NULL); + if (defresolution == NULL) { + defresolution = j2d_ppdFindAttr(ppd, "Resolution", NULL); + } + if (defresolution != NULL) { + int matches = sscanf(defresolution->value, "%dx%ddpi", &defx, &defy); + if (matches == 2) { + if (defx <= 0 || defy <= 0) { + defx = 0; + defy = 0; + } + } else { + matches = sscanf(defresolution->value, "%ddpi", &defx); + if (matches == 1) { + if (defx <= 0) { + defx = 0; + } else { + defy = defx; + } + } + } + if (defx > 0) { + jobject rxObj, ryObj; + rxObj = (*env)->NewObject(env, intCls, intCtr, defx); + CHECK_NULL(rxObj); + ryObj = (*env)->NewObject(env, intCls, intCtr, defy); + CHECK_NULL(ryObj); + (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, rxObj); + (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, ryObj); + (*env)->CallBooleanMethod(env, arrayList, arrListAddMID, dpi); } } } diff --git a/test/jdk/javax/print/PrintablePrintDPI.java b/test/jdk/javax/print/PrintablePrintDPI.java index 6cae2be532c..6b5e83df233 100644 --- a/test/jdk/javax/print/PrintablePrintDPI.java +++ b/test/jdk/javax/print/PrintablePrintDPI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2025, BELLSOFT. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -54,7 +54,7 @@ import java.awt.print.PrinterJob; /* * @test - * @bug 8251928 + * @bug 8251928 8375221 * @key printer * @summary Printable.print method should reflect printer's DPI * @library /java/awt/regtesthelpers @@ -201,7 +201,9 @@ public class PrintablePrintDPI implements Printable { attributeSet.add(OrientationRequested.PORTRAIT); job.setPrintService(printService); job.setPrintable(this); - job.print(attributeSet); + if (job.printDialog(attributeSet)) { + job.print(attributeSet); + } } catch (PrinterException ex) { throw new RuntimeException(ex); } From e88edd0bc63e0a39f42a6a9e1ced61a79f84ad73 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Fri, 23 Jan 2026 18:53:48 +0000 Subject: [PATCH 026/105] 8375338: sun/awt/image/ImageRepresentation/LUTCompareTest.java fails with -Xcheck:jni Reviewed-by: aivanov, serb, krk --- .../share/native/libawt/awt/image/awt_ImageRep.c | 6 +++--- .../sun/awt/image/ImageRepresentation/LUTCompareTest.java | 7 ++++--- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c b/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c index 6079b9e76b8..3cb2df0e0e9 100644 --- a/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c +++ b/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -227,7 +227,7 @@ Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls, /* Release the locked arrays */ (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); - (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, 0); return JNI_TRUE; } @@ -385,7 +385,7 @@ Java_sun_awt_image_ImageRepresentation_setDiffICM(JNIEnv *env, jclass cls, } (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); - (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, 0); return JNI_TRUE; } diff --git a/test/jdk/sun/awt/image/ImageRepresentation/LUTCompareTest.java b/test/jdk/sun/awt/image/ImageRepresentation/LUTCompareTest.java index aca2ff1071c..498fe227651 100644 --- a/test/jdk/sun/awt/image/ImageRepresentation/LUTCompareTest.java +++ b/test/jdk/sun/awt/image/ImageRepresentation/LUTCompareTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2026, 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 @@ -23,12 +23,13 @@ /* * @test - * @bug 6570475 + * @bug 6570475 8375338 * @summary Test verifies that palette comparison procedure of * ImageRepresentation class does not produce extra transparent * pixels. * - * @run main LUTCompareTest + * @run main/othervm LUTCompareTest + * @run main/othervm -Xcheck:jni LUTCompareTest */ From e617ccd529657440eaf20ed68794fea6f6c07fee Mon Sep 17 00:00:00 2001 From: Phil Race Date: Fri, 23 Jan 2026 19:12:54 +0000 Subject: [PATCH 027/105] 8375480: Remove usage of AppContext from javax/swing/text Reviewed-by: serb, psadhukhan --- .../javax/swing/text/JTextComponent.java | 45 ++---- .../classes/javax/swing/text/LayoutQueue.java | 22 +-- .../javax/swing/text/html/HTMLEditorKit.java | 14 +- .../javax/swing/text/html/parser/DTD.java | 28 +--- .../javax/swing/text/html/parser/Element.java | 12 +- .../text/html/parser/ParserDelegator.java | 14 +- .../swing/Security/6938813/bug6938813.java | 128 ------------------ .../swing/text/LayoutQueue/Test6588003.java | 60 -------- .../swing/text/html/parser/Test8017492.java | 94 ------------- 9 files changed, 36 insertions(+), 381 deletions(-) delete mode 100644 test/jdk/javax/swing/Security/6938813/bug6938813.java delete mode 100644 test/jdk/javax/swing/text/LayoutQueue/Test6588003.java delete mode 100644 test/jdk/javax/swing/text/html/parser/Test8017492.java diff --git a/src/java.desktop/share/classes/javax/swing/text/JTextComponent.java b/src/java.desktop/share/classes/javax/swing/text/JTextComponent.java index 03e04d1c1a7..59cee1e12ee 100644 --- a/src/java.desktop/share/classes/javax/swing/text/JTextComponent.java +++ b/src/java.desktop/share/classes/javax/swing/text/JTextComponent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -62,9 +62,6 @@ import javax.accessibility.*; import javax.print.attribute.*; -import sun.awt.AppContext; - - import sun.swing.PrintingStatus; import sun.swing.SwingUtilities2; import sun.swing.text.TextComponentPrintable; @@ -1097,22 +1094,16 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A return getKeymapTable().get(nm); } - private static HashMap getKeymapTable() { - synchronized (KEYMAP_TABLE) { - AppContext appContext = AppContext.getAppContext(); - @SuppressWarnings("unchecked") - HashMap keymapTable = - (HashMap)appContext.get(KEYMAP_TABLE); - if (keymapTable == null) { - keymapTable = new HashMap(17); - appContext.put(KEYMAP_TABLE, keymapTable); - //initialize default keymap - Keymap binding = addKeymap(DEFAULT_KEYMAP, null); - binding.setDefaultAction(new - DefaultEditorKit.DefaultKeyTypedAction()); - } - return keymapTable; + private static HashMap keymapTable; + + private static synchronized HashMap getKeymapTable() { + if (keymapTable == null) { + keymapTable = new HashMap(17); + //initialize default keymap + Keymap binding = addKeymap(DEFAULT_KEYMAP, null); + binding.setDefaultAction(new DefaultEditorKit.DefaultKeyTypedAction()); } + return keymapTable; } /** @@ -1653,7 +1644,7 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A public void removeNotify() { super.removeNotify(); if (getFocusedComponent() == this) { - AppContext.getAppContext().remove(FOCUSED_COMPONENT); + focusedComponent = null; } } @@ -4084,13 +4075,14 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A } } + private static JTextComponent focusedComponent; + /** * Returns the JTextComponent that most recently had focus. The returned * value may currently have focus. */ static final JTextComponent getFocusedComponent() { - return (JTextComponent)AppContext.getAppContext(). - get(FOCUSED_COMPONENT); + return focusedComponent; } @SuppressWarnings("deprecation") @@ -4105,9 +4097,6 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A return modifiers; } - private static final Object KEYMAP_TABLE = - new StringBuilder("JTextComponent_KeymapTable"); - // // member variables used for on-the-spot input method // editing style support @@ -4438,9 +4427,6 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A } } - private static final Object FOCUSED_COMPONENT = - new StringBuilder("JTextComponent_FocusedComponent"); - /** * The default keymap that will be shared by all * JTextComponent instances unless they @@ -4493,8 +4479,7 @@ public abstract class JTextComponent extends JComponent implements Scrollable, A // --- FocusListener methods ----------------------------------- public void focusGained(FocusEvent fe) { - AppContext.getAppContext().put(FOCUSED_COMPONENT, - fe.getSource()); + focusedComponent = (JTextComponent)fe.getSource(); } public void focusLost(FocusEvent fe) { diff --git a/src/java.desktop/share/classes/javax/swing/text/LayoutQueue.java b/src/java.desktop/share/classes/javax/swing/text/LayoutQueue.java index 6801a84da5b..1a4e7315eb4 100644 --- a/src/java.desktop/share/classes/javax/swing/text/LayoutQueue.java +++ b/src/java.desktop/share/classes/javax/swing/text/LayoutQueue.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2026, 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 @@ -25,7 +25,6 @@ package javax.swing.text; import java.util.Vector; -import sun.awt.AppContext; /** * A queue of text layout tasks. @@ -36,11 +35,11 @@ import sun.awt.AppContext; */ public class LayoutQueue { - private static final Object DEFAULT_QUEUE = new Object(); - private Vector tasks; private Thread worker; + private static LayoutQueue defaultQueue; + /** * Construct a layout queue. */ @@ -53,15 +52,10 @@ public class LayoutQueue { * @return the default layout queue */ public static LayoutQueue getDefaultQueue() { - AppContext ac = AppContext.getAppContext(); - synchronized (DEFAULT_QUEUE) { - LayoutQueue defaultQueue = (LayoutQueue) ac.get(DEFAULT_QUEUE); - if (defaultQueue == null) { - defaultQueue = new LayoutQueue(); - ac.put(DEFAULT_QUEUE, defaultQueue); - } - return defaultQueue; + if (defaultQueue == null) { + defaultQueue = new LayoutQueue(); } + return defaultQueue; } /** @@ -70,9 +64,7 @@ public class LayoutQueue { * @param q the new queue. */ public static void setDefaultQueue(LayoutQueue q) { - synchronized (DEFAULT_QUEUE) { - AppContext.getAppContext().put(DEFAULT_QUEUE, q); - } + defaultQueue = q; } /** diff --git a/src/java.desktop/share/classes/javax/swing/text/html/HTMLEditorKit.java b/src/java.desktop/share/classes/javax/swing/text/html/HTMLEditorKit.java index 53ceea32668..b5b75e1067b 100644 --- a/src/java.desktop/share/classes/javax/swing/text/html/HTMLEditorKit.java +++ b/src/java.desktop/share/classes/javax/swing/text/html/HTMLEditorKit.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -92,7 +92,6 @@ import javax.swing.text.ViewFactory; import javax.swing.text.html.parser.ParserDelegator; import sun.swing.SwingAccessor; -import sun.awt.AppContext; import static java.nio.charset.StandardCharsets.ISO_8859_1; @@ -432,11 +431,7 @@ public class HTMLEditorKit extends StyledEditorKit implements Accessible { * @param s a StyleSheet */ public void setStyleSheet(StyleSheet s) { - if (s == null) { - AppContext.getAppContext().remove(DEFAULT_STYLES_KEY); - } else { - AppContext.getAppContext().put(DEFAULT_STYLES_KEY, s); - } + defaultStyles = s; } /** @@ -448,12 +443,8 @@ public class HTMLEditorKit extends StyledEditorKit implements Accessible { * @return the StyleSheet */ public StyleSheet getStyleSheet() { - AppContext appContext = AppContext.getAppContext(); - StyleSheet defaultStyles = (StyleSheet) appContext.get(DEFAULT_STYLES_KEY); - if (defaultStyles == null) { defaultStyles = new StyleSheet(); - appContext.put(DEFAULT_STYLES_KEY, defaultStyles); try (InputStream is = HTMLEditorKit.getResourceAsStream(DEFAULT_CSS); InputStreamReader isr = new InputStreamReader(is, ISO_8859_1); Reader r = new BufferedReader(isr)) @@ -692,6 +683,7 @@ public class HTMLEditorKit extends StyledEditorKit implements Accessible { private static final ViewFactory defaultFactory = new HTMLFactory(); MutableAttributeSet input; + private static StyleSheet defaultStyles = null; private static final Object DEFAULT_STYLES_KEY = new Object(); private LinkController linkHandler = new LinkController(); private static Parser defaultParser = null; diff --git a/src/java.desktop/share/classes/javax/swing/text/html/parser/DTD.java b/src/java.desktop/share/classes/javax/swing/text/html/parser/DTD.java index e9999c679eb..d3a4fa76306 100644 --- a/src/java.desktop/share/classes/javax/swing/text/html/parser/DTD.java +++ b/src/java.desktop/share/classes/javax/swing/text/html/parser/DTD.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2026, 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 @@ -25,8 +25,6 @@ package javax.swing.text.html.parser; -import sun.awt.AppContext; - import java.io.PrintStream; import java.io.File; import java.io.FileInputStream; @@ -403,11 +401,6 @@ class DTD implements DTDConstants { return name; } - /** - * The hashtable key of DTDs in AppContext. - */ - private static final Object DTD_HASH_KEY = new Object(); - /** * Put a name and appropriate DTD to hashtable. * @@ -415,7 +408,7 @@ class DTD implements DTDConstants { * @param dtd the DTD */ public static void putDTDHash(String name, DTD dtd) { - getDtdHash().put(name, dtd); + DTD_MAP.put(name, dtd); } /** @@ -430,27 +423,14 @@ class DTD implements DTDConstants { */ public static DTD getDTD(String name) throws IOException { name = name.toLowerCase(); - DTD dtd = getDtdHash().get(name); + DTD dtd = DTD_MAP.get(name); if (dtd == null) dtd = new DTD(name); return dtd; } - private static Hashtable getDtdHash() { - AppContext appContext = AppContext.getAppContext(); - - @SuppressWarnings("unchecked") - Hashtable result = (Hashtable) appContext.get(DTD_HASH_KEY); - - if (result == null) { - result = new Hashtable(); - - appContext.put(DTD_HASH_KEY, result); - } - - return result; - } + private static final Hashtable DTD_MAP = new Hashtable(); /** * Recreates a DTD from an archived format. diff --git a/src/java.desktop/share/classes/javax/swing/text/html/parser/Element.java b/src/java.desktop/share/classes/javax/swing/text/html/parser/Element.java index cf8ea622c9b..8dd00373636 100644 --- a/src/java.desktop/share/classes/javax/swing/text/html/parser/Element.java +++ b/src/java.desktop/share/classes/javax/swing/text/html/parser/Element.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2026, 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 @@ -28,7 +28,6 @@ package javax.swing.text.html.parser; import java.io.Serializable; import java.util.BitSet; import java.util.Map; -import sun.awt.AppContext; /** * An element as described in a DTD using the ELEMENT construct. @@ -107,17 +106,14 @@ public final class Element implements DTDConstants, Serializable { this.name = name; this.index = index; if (index > getMaxIndex()) { - AppContext.getAppContext().put(MAX_INDEX_KEY, index); + maxIndex = index; } } - private static final Object MAX_INDEX_KEY = new Object(); + private static int maxIndex = 0; static int getMaxIndex() { - Integer value = (Integer) AppContext.getAppContext().get(MAX_INDEX_KEY); - return (value != null) - ? value.intValue() - : 0; + return maxIndex; } /** diff --git a/src/java.desktop/share/classes/javax/swing/text/html/parser/ParserDelegator.java b/src/java.desktop/share/classes/javax/swing/text/html/parser/ParserDelegator.java index 2d541abc06f..6971f313558 100644 --- a/src/java.desktop/share/classes/javax/swing/text/html/parser/ParserDelegator.java +++ b/src/java.desktop/share/classes/javax/swing/text/html/parser/ParserDelegator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2026, 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 @@ -24,8 +24,6 @@ */ package javax.swing.text.html.parser; -import sun.awt.AppContext; - import javax.swing.text.html.HTMLEditorKit; import java.io.BufferedInputStream; import java.io.IOException; @@ -52,7 +50,8 @@ import java.io.Serializable; */ @SuppressWarnings("serial") // Same-version serialization only public class ParserDelegator extends HTMLEditorKit.Parser implements Serializable { - private static final Object DTD_KEY = new Object(); + + private static DTD dtd = null; /** * Sets the default DTD. @@ -62,10 +61,6 @@ public class ParserDelegator extends HTMLEditorKit.Parser implements Serializabl } private static synchronized DTD getDefaultDTD() { - AppContext appContext = AppContext.getAppContext(); - - DTD dtd = (DTD) appContext.get(DTD_KEY); - if (dtd == null) { DTD _dtd = null; // (PENDING) Hate having to hard code! @@ -77,10 +72,7 @@ public class ParserDelegator extends HTMLEditorKit.Parser implements Serializabl System.out.println("Throw an exception: could not get default dtd: " + nm); } dtd = createDTD(_dtd, nm); - - appContext.put(DTD_KEY, dtd); } - return dtd; } diff --git a/test/jdk/javax/swing/Security/6938813/bug6938813.java b/test/jdk/javax/swing/Security/6938813/bug6938813.java deleted file mode 100644 index 8f5e3fc3505..00000000000 --- a/test/jdk/javax/swing/Security/6938813/bug6938813.java +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright (c) 2010, 2017, 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 - * @key headful - * @bug 6938813 - * @summary Swing mutable statics - * @author Pavel Porvatov - * @modules java.desktop/javax.swing.text.html.parser:open - * @modules java.desktop/sun.awt - */ - -import sun.awt.AppContext; -import sun.awt.SunToolkit; - -import javax.swing.text.html.HTMLEditorKit; -import javax.swing.text.html.StyleSheet; -import javax.swing.text.html.parser.DTD; -import javax.swing.text.html.parser.ParserDelegator; -import java.lang.reflect.Field; - -public class bug6938813 { - public static final String DTD_KEY = "dtd_key"; - - private static volatile StyleSheet styleSheet; - - public static void main(String[] args) throws Exception { - // Run validation and init values for this AppContext - validate(); - - Thread thread = new ThreadInAnotherAppContext(); - - thread.start(); - thread.join(); - } - - private static void validate() throws Exception { - AppContext appContext = AppContext.getAppContext(); - - assertTrue(DTD.getDTD(DTD_KEY).getName().equals(DTD_KEY), "DTD.getDTD() mixed AppContexts"); - - // Spoil hash value - DTD invalidDtd = DTD.getDTD("invalid DTD"); - - DTD.putDTDHash(DTD_KEY, invalidDtd); - - assertTrue(DTD.getDTD(DTD_KEY) == invalidDtd, "Something wrong with DTD.getDTD()"); - - Object dtdKey = getParserDelegator_DTD_KEY(); - - assertTrue(appContext.get(dtdKey) == null, "ParserDelegator mixed AppContexts"); - - // Init default DTD - new ParserDelegator(); - - Object dtdValue = appContext.get(dtdKey); - - assertTrue(dtdValue != null, "ParserDelegator.defaultDTD isn't initialized"); - - // Try reinit default DTD - new ParserDelegator(); - - assertTrue(dtdValue == appContext.get(dtdKey), "ParserDelegator.defaultDTD created a duplicate"); - - HTMLEditorKit htmlEditorKit = new HTMLEditorKit(); - - if (styleSheet == null) { - // First AppContext - styleSheet = htmlEditorKit.getStyleSheet(); - - assertTrue(styleSheet != null, "htmlEditorKit.getStyleSheet() returns null"); - assertTrue(htmlEditorKit.getStyleSheet() == styleSheet, "Something wrong with htmlEditorKit.getStyleSheet()"); - } else { - assertTrue(htmlEditorKit.getStyleSheet() != styleSheet, "HtmlEditorKit.getStyleSheet() mixed AppContexts"); - } - } - - private static void assertTrue(boolean b, String msg) { - if (!b) { - throw new RuntimeException("Test failed: " + msg); - } - } - - private static Object getParserDelegator_DTD_KEY() throws Exception { - Field field = ParserDelegator.class.getDeclaredField("DTD_KEY"); - - field.setAccessible(true); - - return field.get(null); - } - - private static class ThreadInAnotherAppContext extends Thread { - public ThreadInAnotherAppContext() { - super(new ThreadGroup("6938813"), "ThreadInAnotherAppContext"); - } - - public void run() { - SunToolkit.createNewAppContext(); - - try { - validate(); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - } -} diff --git a/test/jdk/javax/swing/text/LayoutQueue/Test6588003.java b/test/jdk/javax/swing/text/LayoutQueue/Test6588003.java deleted file mode 100644 index 561ac594a47..00000000000 --- a/test/jdk/javax/swing/text/LayoutQueue/Test6588003.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2007, 2015, 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 6588003 - @summary LayoutQueue should not share its DefaultQueue across AppContexts - @author Peter Zhelezniakov - @modules java.desktop/sun.awt - @run main Test6588003 -*/ - -import javax.swing.text.LayoutQueue; -import sun.awt.SunToolkit; - -public class Test6588003 implements Runnable { - private static final LayoutQueue DEFAULT = new LayoutQueue(); - - public static void main(String[] args) throws InterruptedException { - LayoutQueue.setDefaultQueue(DEFAULT); - - ThreadGroup group = new ThreadGroup("Test6588003"); - Thread thread = new Thread(group, new Test6588003()); - thread.start(); - thread.join(); - - if (LayoutQueue.getDefaultQueue() != DEFAULT) { - throw new RuntimeException("Sharing detected"); - } - } - - public void run() { - SunToolkit.createNewAppContext(); - - if (LayoutQueue.getDefaultQueue() == DEFAULT) { - throw new RuntimeException("Sharing detected"); - } - - LayoutQueue.setDefaultQueue(new LayoutQueue()); - } -} diff --git a/test/jdk/javax/swing/text/html/parser/Test8017492.java b/test/jdk/javax/swing/text/html/parser/Test8017492.java deleted file mode 100644 index dbc1e125cf7..00000000000 --- a/test/jdk/javax/swing/text/html/parser/Test8017492.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2013, 2020, 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. - */ - -import java.util.Vector; -import javax.swing.text.html.HTML; -import javax.swing.text.html.HTMLDocument; -import javax.swing.text.html.HTMLEditorKit; -import javax.swing.text.html.parser.DTD; -import javax.swing.text.html.parser.Element; -import sun.awt.SunToolkit; - -/* - * @test - * @bug 8017492 - * @modules java.desktop/sun.awt - * @run main/othervm Test8017492 - * @summary Tests for OutOfMemoryError/NegativeArraySizeException - * @author Sergey Malenkov - */ - -public class Test8017492 { - public static void main(String[] args) throws Exception { - Runnable task = new Runnable() { - @Override - public void run() { - try { - SunToolkit.createNewAppContext(); - DTD dtd = DTD.getDTD("dtd"); - dtd.elements = new Vector() { - @Override - public synchronized int size() { - return Integer.MAX_VALUE; - } - }; - dtd.getElement("element"); - } - catch (Exception exception) { - throw new Error("unexpected", exception); - } - } - }; - // run task with different AppContext - Thread thread = new Thread(new ThreadGroup("$$$"), task); - thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { - @Override - public void uncaughtException(Thread thread, Throwable throwable) { - throwable.printStackTrace(); - throw new RuntimeException(throwable); - } - }); - thread.start(); - thread.join(); - // add error handling - SunToolkit.createNewAppContext(); - HTMLDocument document = new HTMLDocument() { - @Override - public HTMLEditorKit.ParserCallback getReader(int pos) { - return getReader(pos, 0, 0, null); - } - - @Override - public HTMLEditorKit.ParserCallback getReader(int pos, int popDepth, int pushDepth, HTML.Tag insertTag) { - return new HTMLDocument.HTMLReader(pos, popDepth, pushDepth, insertTag) { - @Override - public void handleError(String error, int pos) { - throw new Error(error); - } - }; - } - }; - // run parser - new HTMLEditorKit().insertHTML(document, 0, "text", 0, 0, null); - } -} From e55124041e0181ca14ed95dc5f94d404b7900029 Mon Sep 17 00:00:00 2001 From: Valerie Peng Date: Fri, 23 Jan 2026 19:46:40 +0000 Subject: [PATCH 028/105] 8375549: ConcurrentModificationException if jdk.crypto.disabledAlgorithms has multiple entries with known oid Reviewed-by: mullan, coffeys --- .../util/CryptoAlgorithmConstraints.java | 8 ++-- .../crypto/Cipher/TestDisabledWithOids.java | 47 +++++++++++++++++++ 2 files changed, 52 insertions(+), 3 deletions(-) create mode 100644 test/jdk/javax/crypto/Cipher/TestDisabledWithOids.java diff --git a/src/java.base/share/classes/sun/security/util/CryptoAlgorithmConstraints.java b/src/java.base/share/classes/sun/security/util/CryptoAlgorithmConstraints.java index a8649106a38..ad3beab350f 100644 --- a/src/java.base/share/classes/sun/security/util/CryptoAlgorithmConstraints.java +++ b/src/java.base/share/classes/sun/security/util/CryptoAlgorithmConstraints.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -82,8 +82,10 @@ public class CryptoAlgorithmConstraints extends AbstractAlgorithmConstraints { CryptoAlgorithmConstraints(String propertyName) { super(null); disabledServices = getAlgorithms(propertyName, true); - debug("Before " + Arrays.deepToString(disabledServices.toArray())); - for (String dk : disabledServices) { + String[] entries = disabledServices.toArray(new String[0]); + debug("Before " + Arrays.deepToString(entries)); + + for (String dk : entries) { int idx = dk.indexOf("."); if (idx < 1 || idx == dk.length() - 1) { // wrong syntax: missing "." or empty service or algorithm diff --git a/test/jdk/javax/crypto/Cipher/TestDisabledWithOids.java b/test/jdk/javax/crypto/Cipher/TestDisabledWithOids.java new file mode 100644 index 00000000000..d1d9fa7a5bb --- /dev/null +++ b/test/jdk/javax/crypto/Cipher/TestDisabledWithOids.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2026, 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 8375549 + * @summary Test JCE layer algorithm restriction using algorithms w/ oids + * @library /test/lib + * @run main/othervm -Djdk.crypto.disabledAlgorithms=Cipher.DES,Cipher.RSA/ECB/PKCS1Padding TestDisabledWithOids + * @run main/othervm -Djdk.crypto.disabledAlgorithms=Cipher.RSA/ECB/PKCS1Padding,Cipher.DES TestDisabledWithOids + */ +import java.security.NoSuchAlgorithmException; +import javax.crypto.Cipher; +import jdk.test.lib.Utils; + +public class TestDisabledWithOids { + public static void main(String[] args) throws Exception { + String algo1 = "RSA/ECB/PKCS1Padding"; + String algo2 = "DES"; + + Utils.runAndCheckException(() -> Cipher.getInstance(algo1), + NoSuchAlgorithmException.class); + Utils.runAndCheckException(() -> Cipher.getInstance(algo2), + NoSuchAlgorithmException.class); + System.out.println("Done"); + } +} From 44b74e165e2d3ea79397d6f1ddbef94f51ac56c7 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Fri, 23 Jan 2026 20:20:22 +0000 Subject: [PATCH 029/105] 8375351: Remove usage of AppContext from print implementation Reviewed-by: serb, tr --- .../javax/print/PrintServiceLookup.java | 42 ++++--------------- .../print/StreamPrintServiceFactory.java | 18 +++----- .../FlushCustomClassLoader.java | 11 ----- 3 files changed, 15 insertions(+), 56 deletions(-) diff --git a/src/java.desktop/share/classes/javax/print/PrintServiceLookup.java b/src/java.desktop/share/classes/javax/print/PrintServiceLookup.java index 15a7fbbaa00..ee3f6a449b7 100644 --- a/src/java.desktop/share/classes/javax/print/PrintServiceLookup.java +++ b/src/java.desktop/share/classes/javax/print/PrintServiceLookup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -32,7 +32,6 @@ import java.util.ServiceLoader; import javax.print.attribute.AttributeSet; -import sun.awt.AppContext; /** * Implementations of this class provide lookup services for print services @@ -58,35 +57,14 @@ public abstract class PrintServiceLookup { protected PrintServiceLookup() {} /** - * Contains a lists of services. + * The list of lookup services. */ - static class Services { - - /** - * The list of lookup services. - */ - private ArrayList listOfLookupServices = null; - - /** - * The list of registered services. - */ - private ArrayList registeredServices = null; - } + private static ArrayList listOfLookupServices = null; /** - * Returns the services from the current appcontext. - * - * @return the services + * The list of registered services. */ - private static Services getServicesForContext() { - Services services = - (Services)AppContext.getAppContext().get(Services.class); - if (services == null) { - services = new Services(); - AppContext.getAppContext().put(Services.class, services); - } - return services; - } + private static ArrayList registeredServices = null; /** * Returns the list of lookup services. @@ -94,7 +72,7 @@ public abstract class PrintServiceLookup { * @return the list of lookup services */ private static ArrayList getListOfLookupServices() { - return getServicesForContext().listOfLookupServices; + return listOfLookupServices; } /** @@ -103,8 +81,7 @@ public abstract class PrintServiceLookup { * @return the list of lookup services */ private static ArrayList initListOfLookupServices() { - ArrayList listOfLookupServices = new ArrayList<>(); - getServicesForContext().listOfLookupServices = listOfLookupServices; + listOfLookupServices = new ArrayList<>(); return listOfLookupServices; } @@ -114,7 +91,7 @@ public abstract class PrintServiceLookup { * @return the list of registered services */ private static ArrayList getRegisteredServices() { - return getServicesForContext().registeredServices; + return registeredServices; } /** @@ -123,8 +100,7 @@ public abstract class PrintServiceLookup { * @return the list of registered services */ private static ArrayList initRegisteredServices() { - ArrayList registeredServices = new ArrayList<>(); - getServicesForContext().registeredServices = registeredServices; + registeredServices = new ArrayList<>(); return registeredServices; } diff --git a/src/java.desktop/share/classes/javax/print/StreamPrintServiceFactory.java b/src/java.desktop/share/classes/javax/print/StreamPrintServiceFactory.java index 7d696f14a94..2667587e9b2 100644 --- a/src/java.desktop/share/classes/javax/print/StreamPrintServiceFactory.java +++ b/src/java.desktop/share/classes/javax/print/StreamPrintServiceFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -33,8 +33,6 @@ import java.util.ServiceLoader; import javax.print.attribute.PrintRequestAttributeSet; -import sun.awt.AppContext; - /** * A {@code StreamPrintServiceFactory} is the factory for * {@link StreamPrintService} instances, which can print to an output stream in @@ -63,24 +61,20 @@ public abstract class StreamPrintServiceFactory { static class Services { /** - * The list of factories which will be stored per appcontext. + * The list of factories. */ private ArrayList listOfFactories = null; } + private static final Services SERVICES = new Services(); + /** - * Returns the services from the current appcontext. + * Returns the singleton Services instance. * * @return the services */ private static Services getServices() { - Services services = - (Services)AppContext.getAppContext().get(Services.class); - if (services == null) { - services = new Services(); - AppContext.getAppContext().put(Services.class, services); - } - return services; + return SERVICES; } /** diff --git a/test/jdk/javax/print/PrintServiceLookup/FlushCustomClassLoader.java b/test/jdk/javax/print/PrintServiceLookup/FlushCustomClassLoader.java index c16fe0e5a82..8125b656de4 100644 --- a/test/jdk/javax/print/PrintServiceLookup/FlushCustomClassLoader.java +++ b/test/jdk/javax/print/PrintServiceLookup/FlushCustomClassLoader.java @@ -56,17 +56,6 @@ public final class FlushCustomClassLoader { } private static Reference getLoader(String m) throws Exception { - /* - * The print services are stored per the AppContext, and each AppContext - * caches the "current" class loader during creation. - * see javax.print.PrintServiceLookup. - * - * To prevent AppContext from cache our test loader we force AppContext - * creation early by the invokeAndWait. - * The "EventQueue.invokeAndWait(() -> {});" can be removed when the - * AppContext usage will be deleted in the PrintServiceLookup - */ - EventQueue.invokeAndWait(() -> {}); URL url = FlushCustomClassLoader.class.getProtectionDomain() .getCodeSource().getLocation(); From a3b1aa9f7dce30a1c5967cb15a5d523e3d7ea72d Mon Sep 17 00:00:00 2001 From: Yasumasa Suenaga Date: Sat, 24 Jan 2026 08:43:37 +0000 Subject: [PATCH 030/105] 8374482: SA does not handle signal handler frame in mixed jstack Reviewed-by: cjplummer, kevinw --- .../linux/native/libsaproc/symtab.c | 25 +++++- .../hotspot/debugger/linux/LinuxDebugger.java | 11 ++- .../debugger/linux/LinuxDebuggerLocal.java | 8 +- .../linux/amd64/LinuxAMD64CFrame.java | 56 +++++++++++++- .../linux/amd64/LinuxAMD64ThreadContext.java | 22 +++++- .../sa/TestJhsdbJstackMixedCore.java | 76 +++++++++++++++++++ 6 files changed, 188 insertions(+), 10 deletions(-) create mode 100644 test/hotspot/jtreg/serviceability/sa/TestJhsdbJstackMixedCore.java diff --git a/src/jdk.hotspot.agent/linux/native/libsaproc/symtab.c b/src/jdk.hotspot.agent/linux/native/libsaproc/symtab.c index 07cbb46d045..c8f3fb2ed4c 100644 --- a/src/jdk.hotspot.agent/linux/native/libsaproc/symtab.c +++ b/src/jdk.hotspot.agent/linux/native/libsaproc/symtab.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2026, 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 @@ -550,14 +550,33 @@ uintptr_t search_symbol(struct symtab* symtab, uintptr_t base, return (uintptr_t) NULL; } +static bool is_in(uintptr_t offset, struct elf_symbol* sym) { + if (sym->size == 0 && offset == sym->offset) { + // offset points to the top of the symbol. + // Some functions have size 0. For example, __restore_rt() (signal trampoline + // in glibc) would be detected as out of the function incorrectly, even if it + // points to the top of the instruction address, because the size of + // __restore_rt() is 0 (you can see this with "readelf -s libc.so.6" when + // debug symbols are available). + // Hence we need to treat this as a special case if the function size is 0, + // only the exact symbol address should be treated as inside. + return true; + } else if (offset >= sym->offset && offset < sym->offset + sym->size) { + // offset is in address range of the symbol + return true; + } + + // offset is out of address range of the symbol + return false; +} + const char* nearest_symbol(struct symtab* symtab, uintptr_t offset, uintptr_t* poffset) { int n = 0; if (!symtab) return NULL; for (; n < symtab->num_symbols; n++) { struct elf_symbol* sym = &(symtab->symbols[n]); - if (sym->name != NULL && - offset >= sym->offset && offset < sym->offset + sym->size) { + if (sym->name != NULL && is_in(offset, sym)) { if (poffset) *poffset = (offset - sym->offset); return sym->name; } diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java index 1106d846eca..a53b8a0a282 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2026, 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 @@ -33,6 +33,14 @@ import sun.jvm.hotspot.debugger.cdbg.*; by the architecture-specific subpackages. */ public interface LinuxDebugger extends JVMDebugger { + // SIGHANDLER_NAMES holds the name of signal handler. + public static final List SIGHANDLER_NAMES = List.of( + // For AMD64 + // - sysdeps/unix/sysv/linux/x86_64/libc_sigaction.c in glibc + // - gdb/amd64-linux-tdep.c in GDB + "__restore_rt" + ); + public String addressValueToString(long address) throws DebuggerException; public boolean readJBoolean(long address) throws DebuggerException; public byte readJByte(long address) throws DebuggerException; @@ -52,6 +60,7 @@ public interface LinuxDebugger extends JVMDebugger { public long[] getThreadIntegerRegisterSet(int lwp_id) throws DebuggerException; public long getAddressValue(Address addr) throws DebuggerException; public Address findLibPtrByAddress(Address pc); + public boolean isSignalTrampoline(Address pc); // For LinuxCDebugger public List getThreadList(); diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java index 261df12c8f1..9a75511e44d 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2026, 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 @@ -130,6 +130,12 @@ public class LinuxDebuggerLocal extends DebuggerBase implements LinuxDebugger { : new LinuxAddress(this, ptr); } + @Override + public boolean isSignalTrampoline(Address pc) { + var sym = lookup(getAddressValue(pc)); + return sym == null ? false : SIGHANDLER_NAMES.contains(sym.getName()); + } + // Note on Linux threads are really processes. When target process is // attached by a serviceability agent thread, only that thread can do // ptrace operations on the target. This is because from kernel's point diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java index 612203634f3..4bf6a0305a3 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2026, 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 @@ -24,9 +24,12 @@ package sun.jvm.hotspot.debugger.linux.amd64; +import java.util.function.Function; + import sun.jvm.hotspot.debugger.*; import sun.jvm.hotspot.debugger.amd64.*; import sun.jvm.hotspot.debugger.linux.*; +import sun.jvm.hotspot.debugger.linux.amd64.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; import sun.jvm.hotspot.runtime.*; @@ -34,6 +37,36 @@ import sun.jvm.hotspot.runtime.amd64.*; public final class LinuxAMD64CFrame extends BasicCFrame { + private static LinuxAMD64CFrame getFrameFromReg(LinuxDebugger dbg, Function getreg) { + Address rip = getreg.apply(AMD64ThreadContext.RIP); + Address rsp = getreg.apply(AMD64ThreadContext.RSP); + Address libptr = dbg.findLibPtrByAddress(rip); + Address cfa = getreg.apply(AMD64ThreadContext.RBP); + DwarfParser dwarf = null; + + if (libptr != null) { // Native frame + dwarf = new DwarfParser(libptr); + try { + dwarf.processDwarf(rip); + } catch (DebuggerException e) { + // DWARF processing should succeed when the frame is native + // but it might fail if Common Information Entry (CIE) has language + // personality routine and/or Language Specific Data Area (LSDA). + return new LinuxAMD64CFrame(dbg, rsp, cfa, rip, dwarf, true); + } + + cfa = getreg.apply(dwarf.getCFARegister()) + .addOffsetTo(dwarf.getCFAOffset()); + } + + return (cfa == null) ? null + : new LinuxAMD64CFrame(dbg, rsp, cfa, rip, dwarf); + } + + public static LinuxAMD64CFrame getTopFrame(LinuxDebugger dbg, Address rip, ThreadContext context) { + return getFrameFromReg(dbg, context::getRegisterAsAddress); + } + public static LinuxAMD64CFrame getTopFrame(LinuxDebugger dbg, Address rsp, Address rip, ThreadContext context) { Address libptr = dbg.findLibPtrByAddress(rip); Address cfa = context.getRegisterAsAddress(AMD64ThreadContext.RBP); @@ -80,8 +113,12 @@ public final class LinuxAMD64CFrame extends BasicCFrame { // override base class impl to avoid ELF parsing public ClosestSymbol closestSymbolToPC() { Address symAddr = use1ByteBeforeToLookup ? pc().addOffsetTo(-1) : pc(); - // try native lookup in debugger. - return dbg.lookup(dbg.getAddressValue(symAddr)); + + // Returns a special symbol if the address is signal handler, + // otherwise returns closest symbol generated by LinuxDebugger. + return dbg.isSignalTrampoline(symAddr) + ? new ClosestSymbol("", 0) + : dbg.lookup(dbg.getAddressValue(symAddr)); } public Address pc() { @@ -159,7 +196,12 @@ public final class LinuxAMD64CFrame extends BasicCFrame { return null; } - return isValidFrame(nextCFA, isNative) ? nextCFA : null; + if (dbg.isSignalTrampoline(senderPC)) { + // Return without frame check if sender is signal trampoline. + return nextCFA; + } else { + return isValidFrame(nextCFA, isNative) ? nextCFA : null; + } } @Override @@ -173,6 +215,12 @@ public final class LinuxAMD64CFrame extends BasicCFrame { return null; } + if (dbg.isSignalTrampoline(pc())) { + // RSP points signal context + // https://github.com/torvalds/linux/blob/v6.17/arch/x86/kernel/signal.c#L94 + return getFrameFromReg(dbg, r -> LinuxAMD64ThreadContext.getRegFromSignalTrampoline(this.rsp, r.intValue())); + } + ThreadContext context = th.getContext(); Address nextRSP = sp != null ? sp : getNextRSP(); diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64ThreadContext.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64ThreadContext.java index 3884bab796b..8b2a7301cf2 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64ThreadContext.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64ThreadContext.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2026, 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 @@ -27,6 +27,7 @@ package sun.jvm.hotspot.debugger.linux.amd64; import sun.jvm.hotspot.debugger.*; import sun.jvm.hotspot.debugger.amd64.*; import sun.jvm.hotspot.debugger.linux.*; +import sun.jvm.hotspot.runtime.*; public class LinuxAMD64ThreadContext extends AMD64ThreadContext { private LinuxDebugger debugger; @@ -43,4 +44,23 @@ public class LinuxAMD64ThreadContext extends AMD64ThreadContext { public Address getRegisterAsAddress(int index) { return debugger.newAddress(getRegister(index)); } + + public static Address getRegFromSignalTrampoline(Address sp, int index) { + // ucontext_t is located at top of stack. + // See definition of rt_sigframe in arch/x86/include/asm/sigframe.h + // in Linux Kernel. + Address addrUCMContext = sp.addOffsetTo(40); // offsetof(ucontext_t, uc_mcontext) = 40 + Address addrGRegs = addrUCMContext; // gregs is located at top of ucontext_t + + // They are from sys/ucontext.h + final int REG_RBP = 10; + final int REG_RSP = 15; + final int REG_RIP = 16; + return switch(index) { + case AMD64ThreadContext.RBP -> addrGRegs.getAddressAt(REG_RBP * VM.getVM().getAddressSize()); + case AMD64ThreadContext.RSP -> addrGRegs.getAddressAt(REG_RSP * VM.getVM().getAddressSize()); + case AMD64ThreadContext.RIP -> addrGRegs.getAddressAt(REG_RIP * VM.getVM().getAddressSize()); + default -> throw new IllegalArgumentException("Unsupported register index: " + index); + }; + } } diff --git a/test/hotspot/jtreg/serviceability/sa/TestJhsdbJstackMixedCore.java b/test/hotspot/jtreg/serviceability/sa/TestJhsdbJstackMixedCore.java new file mode 100644 index 00000000000..b8b19c743e9 --- /dev/null +++ b/test/hotspot/jtreg/serviceability/sa/TestJhsdbJstackMixedCore.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2026, NTT DATA + * 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. + */ + +import jdk.test.lib.JDKToolFinder; +import jdk.test.lib.JDKToolLauncher; +import jdk.test.lib.SA.SATestUtils; +import jdk.test.lib.Utils; +import jdk.test.lib.apps.LingeredApp; +import jdk.test.lib.process.OutputAnalyzer; +import jdk.test.lib.util.CoreUtils; + +/** + * @test + * @bug 8374482 + * @requires (os.family == "linux") & (vm.hasSA) + * @requires os.arch == "amd64" + * @library /test/lib + * @run driver TestJhsdbJstackMixedCore + */ +public class TestJhsdbJstackMixedCore { + + private static void runJstackMixed(String coreFileName) throws Exception { + JDKToolLauncher launcher = JDKToolLauncher.createUsingTestJDK("jhsdb"); + launcher.addVMArgs(Utils.getTestJavaOpts()); + launcher.addToolArg("jstack"); + launcher.addToolArg("--mixed"); + launcher.addToolArg("--exe"); + launcher.addToolArg(JDKToolFinder.getTestJDKTool("java")); + launcher.addToolArg("--core"); + launcher.addToolArg(coreFileName); + + ProcessBuilder pb = SATestUtils.createProcessBuilder(launcher); + Process jhsdb = pb.start(); + OutputAnalyzer out = new OutputAnalyzer(jhsdb); + + jhsdb.waitFor(); + + System.out.println(out.getStdout()); + System.err.println(out.getStderr()); + + out.shouldContain(""); + out.shouldContain("Java_jdk_test_lib_apps_LingeredApp_crash"); + } + + public static void main(String... args) throws Throwable { + LingeredApp app = new LingeredApp(); + app.setForceCrash(true); + LingeredApp.startApp(app, CoreUtils.getAlwaysPretouchArg(true)); + app.waitAppTerminate(); + + String crashOutput = app.getOutput().getStdout(); + String coreFileName = CoreUtils.getCoreFileLocation(crashOutput, app.getPid()); + runJstackMixed(coreFileName); + } +} From a40dbce495db9959624b72ff619e2e7ae7f7fb8b Mon Sep 17 00:00:00 2001 From: Lei Zhu Date: Sat, 24 Jan 2026 14:19:40 +0000 Subject: [PATCH 031/105] 8374293: Jshell throws an error and crashes when using keyword Public Reviewed-by: jlahoda --- .../classes/jdk/jshell/SourceCodeAnalysisImpl.java | 14 ++++---------- .../langtools/jdk/jshell/SnippetHighlightTest.java | 12 +++++++++--- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java b/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java index d5b44b569a4..1cf0c85702f 100644 --- a/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java +++ b/src/jdk.jshell/share/classes/jdk/jshell/SourceCodeAnalysisImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2026, 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 @@ -43,7 +43,6 @@ import com.sun.source.tree.NewClassTree; import com.sun.source.tree.Scope; import com.sun.source.tree.Tree; import com.sun.source.tree.Tree.Kind; -import static com.sun.source.tree.Tree.Kind.METHOD; import com.sun.source.tree.TypeParameterTree; import com.sun.source.tree.VariableTree; import com.sun.source.tree.YieldTree; @@ -81,6 +80,7 @@ import java.util.Iterator; import java.util.List; import java.util.Objects; import java.util.function.Predicate; +import java.util.TreeSet; import javax.lang.model.element.Element; import javax.lang.model.element.ElementKind; @@ -114,7 +114,6 @@ import java.util.Map; import java.util.NoSuchElementException; import java.util.Optional; import java.util.Set; -import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.function.BiConsumer; @@ -149,14 +148,10 @@ import javax.tools.JavaFileManager.Location; import javax.tools.StandardLocation; import jdk.jshell.ExpressionToTypeInfo.ExpressionInfo; -import static jdk.jshell.Util.REPL_DOESNOTMATTER_CLASS_NAME; import static jdk.jshell.SourceCodeAnalysis.Completeness.DEFINITELY_INCOMPLETE; import static jdk.jshell.TreeDissector.printType; import static java.util.stream.Collectors.joining; -import static javax.lang.model.element.ElementKind.CONSTRUCTOR; -import static javax.lang.model.element.ElementKind.MODULE; -import static javax.lang.model.element.ElementKind.PACKAGE; import javax.lang.model.type.IntersectionType; import javax.lang.model.util.Elements; @@ -815,7 +810,7 @@ class SourceCodeAnalysisImpl extends SourceCodeAnalysis { }; String wrappedCode = codeWrap.wrapped(); return this.proc.taskFactory.analyze(codeWrap, task -> { - List result = new ArrayList<>(); + TreeSet result = new TreeSet<>(Comparator.comparing(Highlight::start).thenComparing(Highlight::end)); CompilationUnitTree cut = task.cuTrees().iterator().next(); Trees trees = task.trees(); SourcePositions sp = trees.getSourcePositions(); @@ -1050,8 +1045,7 @@ class SourceCodeAnalysisImpl extends SourceCodeAnalysis { } }.scan(cut, null); result.removeIf(h -> h.start() == h.end()); - Collections.sort(result, (h1, h2) -> h1.start() - h2.start()); - return result; + return new ArrayList<>(result); }); } diff --git a/test/langtools/jdk/jshell/SnippetHighlightTest.java b/test/langtools/jdk/jshell/SnippetHighlightTest.java index dbf3418af83..33f7f263617 100644 --- a/test/langtools/jdk/jshell/SnippetHighlightTest.java +++ b/test/langtools/jdk/jshell/SnippetHighlightTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 8274148 8301580 8359497 + * @bug 8274148 8301580 8359497 8374293 * @summary Check snippet highlighting * @library /tools/lib * @modules jdk.compiler/com.sun.tools.javac.api @@ -122,6 +122,13 @@ public class SnippetHighlightTest extends KullaTesting { """); } + @Test // 8374293: The returned Highlights should not overlap + public void testHighlightsOverlap() { + assertHighlights("public void E test()", "Highlight[start=0, end=6, attributes=[KEYWORD]]", + "Highlight[start=7, end=11, attributes=[KEYWORD]]", + "Highlight[start=14, end=18, attributes=[DECLARATION]]"); + } + private void assertHighlights(String code, String... expected) { List completions = computeHighlights(code); assertEquals(Arrays.asList(expected), completions, "Input: " + code + ", " + completions.toString()); @@ -134,7 +141,6 @@ public class SnippetHighlightTest extends KullaTesting { getAnalysis().highlights(code); return highlights.stream() .map(h -> h.toString()) - .distinct() .collect(Collectors.toList()); } } From 932556026d6d49fe6f74d4ec4afcb72448611766 Mon Sep 17 00:00:00 2001 From: SendaoYan Date: Sun, 25 Jan 2026 01:08:31 +0000 Subject: [PATCH 032/105] 8375683: Add notes for sctp tests Reviewed-by: erikj, vyazici --- doc/testing.html | 16 ++++++++++++++++ doc/testing.md | 26 ++++++++++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/doc/testing.html b/doc/testing.html index 31f4fbd1778..195153c8612 100644 --- a/doc/testing.html +++ b/doc/testing.html @@ -72,6 +72,7 @@ id="toc-notes-for-specific-tests">Notes for Specific Tests
  • Non-US locale
  • PKCS11 Tests
    • +
  • SCTP Tests
  • Testing Ahead-of-time Optimizations
    • @@ -621,6 +622,21 @@ element of the appropriate @Artifact class. (See JTREG="JAVA_OPTIONS=-Djdk.test.lib.artifacts.nsslib-linux_aarch64=/path/to/NSS-libs"

    For more notes about the PKCS11 tests, please refer to test/jdk/sun/security/pkcs11/README.

    +

    SCTP Tests

    +

    The SCTP tests require the SCTP runtime library, which is often not +installed by default in popular Linux distributions. Without this +library, the SCTP tests will be skipped. If you want to enable the SCTP +tests, you should install the SCTP library before running the tests.

    +

    For distributions using the .deb packaging format and the apt tool +(such as Debian, Ubuntu, etc.), try this:

    +
    sudo apt install libsctp1
+sudo modprobe sctp
+lsmod | grep sctp
    +

    For distributions using the .rpm packaging format and the dnf tool +(such as Fedora, Red Hat, etc.), try this:

    +
    sudo dnf install -y lksctp-tools
+sudo modprobe sctp
+lsmod | grep sctp

    Testing Ahead-of-time Optimizations

    One way to improve test coverage of ahead-of-time (AOT) optimizations diff --git a/doc/testing.md b/doc/testing.md index b95f59de9fd..d0e54aab02b 100644 --- a/doc/testing.md +++ b/doc/testing.md @@ -640,6 +640,32 @@ $ make test TEST="jtreg:sun/security/pkcs11/Secmod/AddTrustedCert.java" \ For more notes about the PKCS11 tests, please refer to test/jdk/sun/security/pkcs11/README. + +### SCTP Tests + +The SCTP tests require the SCTP runtime library, which is often not installed +by default in popular Linux distributions. Without this library, the SCTP tests +will be skipped. If you want to enable the SCTP tests, you should install the +SCTP library before running the tests. + +For distributions using the .deb packaging format and the apt tool +(such as Debian, Ubuntu, etc.), try this: + +``` +sudo apt install libsctp1 +sudo modprobe sctp +lsmod | grep sctp +``` + +For distributions using the .rpm packaging format and the dnf tool +(such as Fedora, Red Hat, etc.), try this: + +``` +sudo dnf install -y lksctp-tools +sudo modprobe sctp +lsmod | grep sctp +``` + ### Testing Ahead-of-time Optimizations One way to improve test coverage of ahead-of-time (AOT) optimizations in From 38b66b12581a3745a37589e32aa0fc880d27b4d4 Mon Sep 17 00:00:00 2001 From: Xiaohong Gong Date: Mon, 26 Jan 2026 01:50:57 +0000 Subject: [PATCH 033/105] 8374043: C2: assert(_base >= VectorMask && _base <= VectorZ) failed: Not a Vector Reviewed-by: qamai, vlivanov --- src/hotspot/share/opto/vectorIntrinsics.cpp | 4 ++++ src/hotspot/share/opto/vectornode.cpp | 11 ++++++++++- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/hotspot/share/opto/vectorIntrinsics.cpp b/src/hotspot/share/opto/vectorIntrinsics.cpp index 65d54e076b6..883a0526053 100644 --- a/src/hotspot/share/opto/vectorIntrinsics.cpp +++ b/src/hotspot/share/opto/vectorIntrinsics.cpp @@ -175,6 +175,10 @@ Node* GraphKit::unbox_vector(Node* v, const TypeInstPtr* vbox_type, BasicType el assert(check_vbox(vbox_type), ""); const TypeVect* vt = TypeVect::make(elem_bt, num_elem, is_vector_mask(vbox_type->instance_klass())); Node* unbox = gvn().transform(new VectorUnboxNode(C, vt, v, merged_memory())); + if (gvn().type(unbox)->isa_vect() == nullptr) { + assert(gvn().type(unbox) == Type::TOP, "sanity"); + return nullptr; // not a vector + } return unbox; } diff --git a/src/hotspot/share/opto/vectornode.cpp b/src/hotspot/share/opto/vectornode.cpp index 271dc901dcb..7401efaf7c2 100644 --- a/src/hotspot/share/opto/vectornode.cpp +++ b/src/hotspot/share/opto/vectornode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2026, 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 @@ -1919,6 +1919,15 @@ Node* VectorMaskToLongNode::Ideal_MaskAll(PhaseGVN* phase) { // saved with a predicate type. if (in1->Opcode() == Op_VectorStoreMask) { Node* mask = in1->in(1); + // Skip the optimization if the mask is dead. + if (phase->type(mask) == Type::TOP) { + return nullptr; + } + // If the ideal graph is transformed correctly, the input mask should be a + // vector type node. Following optimization can ignore the mismatched type + // issue. But we still keep the sanity check for the mask type by using + // "is_vect()" in the assertion below, so that there can be less optimizations + // evolved before the compiler finally runs into a problem. assert(!Matcher::mask_op_prefers_predicate(Opcode(), mask->bottom_type()->is_vect()), "sanity"); in1 = mask; } From 90b546925397ff7cdd1591291e1b87d0bac5604a Mon Sep 17 00:00:00 2001 From: Arno Zeller Date: Mon, 26 Jan 2026 08:34:56 +0000 Subject: [PATCH 034/105] 8375999: com/sun/jndi/ldap/LdapPoolTimeoutTest.java fails sporadically on Windows Reviewed-by: jpai, mbaesken --- test/jdk/com/sun/jndi/ldap/LdapPoolTimeoutTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/jdk/com/sun/jndi/ldap/LdapPoolTimeoutTest.java b/test/jdk/com/sun/jndi/ldap/LdapPoolTimeoutTest.java index b47433ca16f..b139f12da25 100644 --- a/test/jdk/com/sun/jndi/ldap/LdapPoolTimeoutTest.java +++ b/test/jdk/com/sun/jndi/ldap/LdapPoolTimeoutTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -131,6 +131,7 @@ public class LdapPoolTimeoutTest { || msg.contains("No route to host") || msg.contains("Timed out waiting for lock") || msg.contains("Connect timed out") + || msg.contains("Connection timed out") || msg.contains("Timeout exceeded while waiting for a connection"))) { // got the expected exception System.out.println("Received expected NamingException with message: " + msg); From 2af271e5e64260f05c01cb94bcf95f80fd69b4ff Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:12:39 +0000 Subject: [PATCH 035/105] 8375436: G1: Convert G1CardSet classes to use Atomic Reviewed-by: kbarrett, iwalulya --- src/hotspot/share/gc/g1/g1CardSet.cpp | 89 +++++++++---------- src/hotspot/share/gc/g1/g1CardSet.hpp | 29 +++--- .../share/gc/g1/g1CardSetContainers.hpp | 36 ++++---- .../gc/g1/g1CardSetContainers.inline.hpp | 49 +++++----- src/hotspot/share/gc/g1/g1CardSetMemory.cpp | 3 +- .../gtest/gc/g1/test_g1CardSetContainers.cpp | 19 ++-- 6 files changed, 115 insertions(+), 110 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1CardSet.cpp b/src/hotspot/share/gc/g1/g1CardSet.cpp index 3441e6bc608..60ad63e812c 100644 --- a/src/hotspot/share/gc/g1/g1CardSet.cpp +++ b/src/hotspot/share/gc/g1/g1CardSet.cpp @@ -29,7 +29,6 @@ #include "gc/shared/gcLogPrecious.hpp" #include "gc/shared/gcTraceTime.inline.hpp" #include "memory/allocation.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/globals_extension.hpp" #include "runtime/java.hpp" #include "utilities/bitMap.inline.hpp" @@ -192,32 +191,32 @@ const char* G1CardSetConfiguration::mem_object_type_name_str(uint index) { void G1CardSetCoarsenStats::reset() { STATIC_ASSERT(ARRAY_SIZE(_coarsen_from) == ARRAY_SIZE(_coarsen_collision)); for (uint i = 0; i < ARRAY_SIZE(_coarsen_from); i++) { - _coarsen_from[i] = 0; - _coarsen_collision[i] = 0; + _coarsen_from[i].store_relaxed(0); + _coarsen_collision[i].store_relaxed(0); } } void G1CardSetCoarsenStats::set(G1CardSetCoarsenStats& other) { STATIC_ASSERT(ARRAY_SIZE(_coarsen_from) == ARRAY_SIZE(_coarsen_collision)); for (uint i = 0; i < ARRAY_SIZE(_coarsen_from); i++) { - _coarsen_from[i] = other._coarsen_from[i]; - _coarsen_collision[i] = other._coarsen_collision[i]; + _coarsen_from[i].store_relaxed(other._coarsen_from[i].load_relaxed()); + _coarsen_collision[i].store_relaxed(other._coarsen_collision[i].load_relaxed()); } } void G1CardSetCoarsenStats::subtract_from(G1CardSetCoarsenStats& other) { STATIC_ASSERT(ARRAY_SIZE(_coarsen_from) == ARRAY_SIZE(_coarsen_collision)); for (uint i = 0; i < ARRAY_SIZE(_coarsen_from); i++) { - _coarsen_from[i] = other._coarsen_from[i] - _coarsen_from[i]; - _coarsen_collision[i] = other._coarsen_collision[i] - _coarsen_collision[i]; + _coarsen_from[i].store_relaxed(other._coarsen_from[i].load_relaxed() - _coarsen_from[i].load_relaxed()); + _coarsen_collision[i].store_relaxed(other._coarsen_collision[i].load_relaxed() - _coarsen_collision[i].load_relaxed()); } } void G1CardSetCoarsenStats::record_coarsening(uint tag, bool collision) { assert(tag < ARRAY_SIZE(_coarsen_from), "tag %u out of bounds", tag); - AtomicAccess::inc(&_coarsen_from[tag], memory_order_relaxed); + _coarsen_from[tag].add_then_fetch(1u, memory_order_relaxed); if (collision) { - AtomicAccess::inc(&_coarsen_collision[tag], memory_order_relaxed); + _coarsen_collision[tag].add_then_fetch(1u, memory_order_relaxed); } } @@ -228,13 +227,13 @@ void G1CardSetCoarsenStats::print_on(outputStream* out) { "Inline->AoC %zu (%zu) " "AoC->BitMap %zu (%zu) " "BitMap->Full %zu (%zu) ", - _coarsen_from[0], _coarsen_collision[0], - _coarsen_from[1], _coarsen_collision[1], + _coarsen_from[0].load_relaxed(), _coarsen_collision[0].load_relaxed(), + _coarsen_from[1].load_relaxed(), _coarsen_collision[1].load_relaxed(), // There is no BitMap at the first level so we can't . - _coarsen_from[3], _coarsen_collision[3], - _coarsen_from[4], _coarsen_collision[4], - _coarsen_from[5], _coarsen_collision[5], - _coarsen_from[6], _coarsen_collision[6] + _coarsen_from[3].load_relaxed(), _coarsen_collision[3].load_relaxed(), + _coarsen_from[4].load_relaxed(), _coarsen_collision[4].load_relaxed(), + _coarsen_from[5].load_relaxed(), _coarsen_collision[5].load_relaxed(), + _coarsen_from[6].load_relaxed(), _coarsen_collision[6].load_relaxed() ); } @@ -248,7 +247,7 @@ class G1CardSetHashTable : public CHeapObj { // the per region cardsets. const static uint GroupBucketClaimSize = 4; // Did we insert at least one card in the table? - bool volatile _inserted_card; + Atomic _inserted_card; G1CardSetMemoryManager* _mm; CardSetHash _table; @@ -311,10 +310,10 @@ public: G1CardSetHashTableValue value(region_idx, G1CardSetInlinePtr()); bool inserted = _table.insert_get(Thread::current(), lookup, value, found, should_grow); - if (!_inserted_card && inserted) { + if (!_inserted_card.load_relaxed() && inserted) { // It does not matter to us who is setting the flag so a regular atomic store // is sufficient. - AtomicAccess::store(&_inserted_card, true); + _inserted_card.store_relaxed(true); } return found.value(); @@ -343,9 +342,9 @@ public: } void reset() { - if (AtomicAccess::load(&_inserted_card)) { + if (_inserted_card.load_relaxed()) { _table.unsafe_reset(InitialLogTableSize); - AtomicAccess::store(&_inserted_card, false); + _inserted_card.store_relaxed(false); } } @@ -455,14 +454,14 @@ void G1CardSet::free_mem_object(ContainerPtr container) { _mm->free(container_type_to_mem_object_type(type), value); } -G1CardSet::ContainerPtr G1CardSet::acquire_container(ContainerPtr volatile* container_addr) { +G1CardSet::ContainerPtr G1CardSet::acquire_container(Atomic* container_addr) { // Update reference counts under RCU critical section to avoid a // use-after-cleapup bug where we increment a reference count for // an object whose memory has already been cleaned up and reused. GlobalCounter::CriticalSection cs(Thread::current()); while (true) { // Get ContainerPtr and increment refcount atomically wrt to memory reuse. - ContainerPtr container = AtomicAccess::load_acquire(container_addr); + ContainerPtr container = container_addr->load_acquire(); uint cs_type = container_type(container); if (container == FullCardSet || cs_type == ContainerInlinePtr) { return container; @@ -503,15 +502,15 @@ class G1ReleaseCardsets : public StackObj { G1CardSet* _card_set; using ContainerPtr = G1CardSet::ContainerPtr; - void coarsen_to_full(ContainerPtr* container_addr) { + void coarsen_to_full(Atomic* container_addr) { while (true) { - ContainerPtr cur_container = AtomicAccess::load_acquire(container_addr); + ContainerPtr cur_container = container_addr->load_acquire(); uint cs_type = G1CardSet::container_type(cur_container); if (cur_container == G1CardSet::FullCardSet) { return; } - ContainerPtr old_value = AtomicAccess::cmpxchg(container_addr, cur_container, G1CardSet::FullCardSet); + ContainerPtr old_value = container_addr->compare_exchange(cur_container, G1CardSet::FullCardSet); if (old_value == cur_container) { _card_set->release_and_maybe_free_container(cur_container); @@ -523,7 +522,7 @@ class G1ReleaseCardsets : public StackObj { public: explicit G1ReleaseCardsets(G1CardSet* card_set) : _card_set(card_set) { } - void operator ()(ContainerPtr* container_addr) { + void operator ()(Atomic* container_addr) { coarsen_to_full(container_addr); } }; @@ -544,10 +543,10 @@ G1AddCardResult G1CardSet::add_to_howl(ContainerPtr parent_container, ContainerPtr container; uint bucket = _config->howl_bucket_index(card_in_region); - ContainerPtr volatile* bucket_entry = howl->container_addr(bucket); + Atomic* bucket_entry = howl->container_addr(bucket); while (true) { - if (AtomicAccess::load(&howl->_num_entries) >= _config->cards_in_howl_threshold()) { + if (howl->_num_entries.load_relaxed() >= _config->cards_in_howl_threshold()) { return Overflow; } @@ -571,7 +570,7 @@ G1AddCardResult G1CardSet::add_to_howl(ContainerPtr parent_container, } if (increment_total && add_result == Added) { - AtomicAccess::inc(&howl->_num_entries, memory_order_relaxed); + howl->_num_entries.add_then_fetch(1u, memory_order_relaxed); } if (to_transfer != nullptr) { @@ -588,7 +587,7 @@ G1AddCardResult G1CardSet::add_to_bitmap(ContainerPtr container, uint card_in_re return bitmap->add(card_offset, _config->cards_in_howl_bitmap_threshold(), _config->max_cards_in_howl_bitmap()); } -G1AddCardResult G1CardSet::add_to_inline_ptr(ContainerPtr volatile* container_addr, ContainerPtr container, uint card_in_region) { +G1AddCardResult G1CardSet::add_to_inline_ptr(Atomic* container_addr, ContainerPtr container, uint card_in_region) { G1CardSetInlinePtr value(container_addr, container); return value.add(card_in_region, _config->inline_ptr_bits_per_card(), _config->max_cards_in_inline_ptr()); } @@ -610,7 +609,7 @@ G1CardSet::ContainerPtr G1CardSet::create_coarsened_array_of_cards(uint card_in_ return new_container; } -bool G1CardSet::coarsen_container(ContainerPtr volatile* container_addr, +bool G1CardSet::coarsen_container(Atomic* container_addr, ContainerPtr cur_container, uint card_in_region, bool within_howl) { @@ -640,7 +639,7 @@ bool G1CardSet::coarsen_container(ContainerPtr volatile* container_addr, ShouldNotReachHere(); } - ContainerPtr old_value = AtomicAccess::cmpxchg(container_addr, cur_container, new_container); // Memory order? + ContainerPtr old_value = container_addr->compare_exchange(cur_container, new_container); // Memory order? if (old_value == cur_container) { // Success. Indicate that the cards from the current card set must be transferred // by this caller. @@ -687,7 +686,7 @@ void G1CardSet::transfer_cards(G1CardSetHashTableValue* table_entry, ContainerPt assert(container_type(source_container) == ContainerHowl, "must be"); // Need to correct for that the Full remembered set occupies more cards than the // AoCS before. - AtomicAccess::add(&_num_occupied, _config->max_cards_in_region() - table_entry->_num_occupied, memory_order_relaxed); + _num_occupied.add_then_fetch(_config->max_cards_in_region() - table_entry->_num_occupied.load_relaxed(), memory_order_relaxed); } } @@ -713,18 +712,18 @@ void G1CardSet::transfer_cards_in_howl(ContainerPtr parent_container, diff -= 1; G1CardSetHowl* howling_array = container_ptr(parent_container); - AtomicAccess::add(&howling_array->_num_entries, diff, memory_order_relaxed); + howling_array->_num_entries.add_then_fetch(diff, memory_order_relaxed); G1CardSetHashTableValue* table_entry = get_container(card_region); assert(table_entry != nullptr, "Table entry not found for transferred cards"); - AtomicAccess::add(&table_entry->_num_occupied, diff, memory_order_relaxed); + table_entry->_num_occupied.add_then_fetch(diff, memory_order_relaxed); - AtomicAccess::add(&_num_occupied, diff, memory_order_relaxed); + _num_occupied.add_then_fetch(diff, memory_order_relaxed); } } -G1AddCardResult G1CardSet::add_to_container(ContainerPtr volatile* container_addr, +G1AddCardResult G1CardSet::add_to_container(Atomic* container_addr, ContainerPtr container, uint card_region, uint card_in_region, @@ -827,8 +826,8 @@ G1AddCardResult G1CardSet::add_card(uint card_region, uint card_in_region, bool } if (increment_total && add_result == Added) { - AtomicAccess::inc(&table_entry->_num_occupied, memory_order_relaxed); - AtomicAccess::inc(&_num_occupied, memory_order_relaxed); + table_entry->_num_occupied.add_then_fetch(1u, memory_order_relaxed); + _num_occupied.add_then_fetch(1u, memory_order_relaxed); } if (should_grow_table) { _table->grow(); @@ -853,7 +852,7 @@ bool G1CardSet::contains_card(uint card_region, uint card_in_region) { return false; } - ContainerPtr container = table_entry->_container; + ContainerPtr container = table_entry->_container.load_relaxed(); if (container == FullCardSet) { // contains_card() is not a performance critical method so we do not hide that // case in the switch below. @@ -889,7 +888,7 @@ void G1CardSet::print_info(outputStream* st, uintptr_t card) { return; } - ContainerPtr container = table_entry->_container; + ContainerPtr container = table_entry->_container.load_relaxed(); if (container == FullCardSet) { st->print("FULL card set)"); return; @@ -940,7 +939,7 @@ void G1CardSet::iterate_cards_during_transfer(ContainerPtr const container, Card void G1CardSet::iterate_containers(ContainerPtrClosure* cl, bool at_safepoint) { auto do_value = [&] (G1CardSetHashTableValue* value) { - cl->do_containerptr(value->_region_idx, value->_num_occupied, value->_container); + cl->do_containerptr(value->_region_idx, value->_num_occupied.load_relaxed(), value->_container.load_relaxed()); return true; }; @@ -1001,11 +1000,11 @@ bool G1CardSet::occupancy_less_or_equal_to(size_t limit) const { } bool G1CardSet::is_empty() const { - return _num_occupied == 0; + return _num_occupied.load_relaxed() == 0; } size_t G1CardSet::occupied() const { - return _num_occupied; + return _num_occupied.load_relaxed(); } size_t G1CardSet::num_containers() { @@ -1051,7 +1050,7 @@ size_t G1CardSet::static_mem_size() { void G1CardSet::clear() { _table->reset(); - _num_occupied = 0; + _num_occupied.store_relaxed(0); _mm->flush(); } diff --git a/src/hotspot/share/gc/g1/g1CardSet.hpp b/src/hotspot/share/gc/g1/g1CardSet.hpp index 9cefc4b1c22..64ddf0ca6a4 100644 --- a/src/hotspot/share/gc/g1/g1CardSet.hpp +++ b/src/hotspot/share/gc/g1/g1CardSet.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -27,6 +27,7 @@ #include "memory/allocation.hpp" #include "memory/memRegion.hpp" +#include "runtime/atomic.hpp" #include "utilities/concurrentHashTable.hpp" class G1CardSetAllocOptions; @@ -154,8 +155,8 @@ public: private: // Indices are "from" indices. - size_t _coarsen_from[NumCoarsenCategories]; - size_t _coarsen_collision[NumCoarsenCategories]; + Atomic _coarsen_from[NumCoarsenCategories]; + Atomic _coarsen_collision[NumCoarsenCategories]; public: G1CardSetCoarsenStats() { reset(); } @@ -271,11 +272,11 @@ private: // Total number of cards in this card set. This is a best-effort value, i.e. there may // be (slightly) more cards in the card set than this value in reality. - size_t _num_occupied; + Atomic _num_occupied; ContainerPtr make_container_ptr(void* value, uintptr_t type); - ContainerPtr acquire_container(ContainerPtr volatile* container_addr); + ContainerPtr acquire_container(Atomic* container_addr); // Returns true if the card set container should be released bool release_container(ContainerPtr container); // Release card set and free if needed. @@ -288,7 +289,7 @@ private: // coarsen_container does not transfer cards from cur_container // to the new container. Transfer is achieved by transfer_cards. // Returns true if this was the thread that coarsened the container (and added the card). - bool coarsen_container(ContainerPtr volatile* container_addr, + bool coarsen_container(Atomic* container_addr, ContainerPtr cur_container, uint card_in_region, bool within_howl = false); @@ -300,9 +301,9 @@ private: void transfer_cards(G1CardSetHashTableValue* table_entry, ContainerPtr source_container, uint card_region); void transfer_cards_in_howl(ContainerPtr parent_container, ContainerPtr source_container, uint card_region); - G1AddCardResult add_to_container(ContainerPtr volatile* container_addr, ContainerPtr container, uint card_region, uint card, bool increment_total = true); + G1AddCardResult add_to_container(Atomic* container_addr, ContainerPtr container, uint card_region, uint card, bool increment_total = true); - G1AddCardResult add_to_inline_ptr(ContainerPtr volatile* container_addr, ContainerPtr container, uint card_in_region); + G1AddCardResult add_to_inline_ptr(Atomic* container_addr, ContainerPtr container, uint card_in_region); G1AddCardResult add_to_array(ContainerPtr container, uint card_in_region); G1AddCardResult add_to_bitmap(ContainerPtr container, uint card_in_region); G1AddCardResult add_to_howl(ContainerPtr parent_container, uint card_region, uint card_in_region, bool increment_total = true); @@ -366,7 +367,6 @@ public: size_t num_containers(); - static G1CardSetCoarsenStats coarsen_stats(); static void print_coarsen_stats(outputStream* out); // Returns size of the actual remembered set containers in bytes. @@ -412,8 +412,15 @@ public: using ContainerPtr = G1CardSet::ContainerPtr; const uint _region_idx; - uint volatile _num_occupied; - ContainerPtr volatile _container; + Atomic _num_occupied; + Atomic _container; + + // Copy constructor needed for use in ConcurrentHashTable. + G1CardSetHashTableValue(const G1CardSetHashTableValue& other) : + _region_idx(other._region_idx), + _num_occupied(other._num_occupied.load_relaxed()), + _container(other._container.load_relaxed()) + { } G1CardSetHashTableValue(uint region_idx, ContainerPtr container) : _region_idx(region_idx), _num_occupied(0), _container(container) { } }; diff --git a/src/hotspot/share/gc/g1/g1CardSetContainers.hpp b/src/hotspot/share/gc/g1/g1CardSetContainers.hpp index 72c7795be2e..78551479e06 100644 --- a/src/hotspot/share/gc/g1/g1CardSetContainers.hpp +++ b/src/hotspot/share/gc/g1/g1CardSetContainers.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, 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 @@ -27,7 +27,7 @@ #include "gc/g1/g1CardSet.hpp" #include "memory/allocation.hpp" -#include "runtime/atomicAccess.hpp" +#include "runtime/atomic.hpp" #include "utilities/bitMap.hpp" #include "utilities/globalDefinitions.hpp" @@ -67,7 +67,7 @@ class G1CardSetInlinePtr : public StackObj { using ContainerPtr = G1CardSet::ContainerPtr; - ContainerPtr volatile * _value_addr; + Atomic* _value_addr; ContainerPtr _value; static const uint SizeFieldLen = 3; @@ -103,7 +103,7 @@ public: explicit G1CardSetInlinePtr(ContainerPtr value) : G1CardSetInlinePtr(nullptr, value) {} - G1CardSetInlinePtr(ContainerPtr volatile* value_addr, ContainerPtr value) : _value_addr(value_addr), _value(value) { + G1CardSetInlinePtr(Atomic* value_addr, ContainerPtr value) : _value_addr(value_addr), _value(value) { assert(G1CardSet::container_type(_value) == G1CardSet::ContainerInlinePtr, "Value " PTR_FORMAT " is not a valid G1CardSetInlinePtr.", p2i(_value)); } @@ -145,13 +145,13 @@ public: // All but inline pointers are of this kind. For those, card entries are stored // directly in the ContainerPtr of the ConcurrentHashTable node. class G1CardSetContainer { - uintptr_t _ref_count; + Atomic _ref_count; protected: ~G1CardSetContainer() = default; public: G1CardSetContainer() : _ref_count(3) { } - uintptr_t refcount() const { return AtomicAccess::load_acquire(&_ref_count); } + uintptr_t refcount() const { return _ref_count.load_acquire(); } bool try_increment_refcount(); @@ -172,7 +172,7 @@ public: using ContainerPtr = G1CardSet::ContainerPtr; private: EntryCountType _size; - EntryCountType volatile _num_entries; + Atomic _num_entries; // VLA implementation. EntryDataType _data[1]; @@ -180,10 +180,10 @@ private: static const EntryCountType EntryMask = LockBitMask - 1; class G1CardSetArrayLocker : public StackObj { - EntryCountType volatile* _num_entries_addr; + Atomic* _num_entries_addr; EntryCountType _local_num_entries; public: - G1CardSetArrayLocker(EntryCountType volatile* value); + G1CardSetArrayLocker(Atomic* value); EntryCountType num_entries() const { return _local_num_entries; } void inc_num_entries() { @@ -192,7 +192,7 @@ private: } ~G1CardSetArrayLocker() { - AtomicAccess::release_store(_num_entries_addr, _local_num_entries); + _num_entries_addr->release_store(_local_num_entries); } }; @@ -213,7 +213,7 @@ public: template void iterate(CardVisitor& found); - size_t num_entries() const { return _num_entries & EntryMask; } + size_t num_entries() const { return _num_entries.load_relaxed() & EntryMask; } static size_t header_size_in_bytes(); @@ -223,7 +223,7 @@ public: }; class G1CardSetBitMap : public G1CardSetContainer { - size_t _num_bits_set; + Atomic _num_bits_set; BitMap::bm_word_t _bits[1]; public: @@ -236,7 +236,7 @@ public: return bm.at(card_idx); } - uint num_bits_set() const { return (uint)_num_bits_set; } + uint num_bits_set() const { return (uint)_num_bits_set.load_relaxed(); } template void iterate(CardVisitor& found, size_t const size_in_bits, uint offset); @@ -255,10 +255,10 @@ class G1CardSetHowl : public G1CardSetContainer { public: typedef uint EntryCountType; using ContainerPtr = G1CardSet::ContainerPtr; - EntryCountType volatile _num_entries; + Atomic _num_entries; private: // VLA implementation. - ContainerPtr _buckets[1]; + Atomic _buckets[1]; // Do not add class member variables beyond this point. // Iterates over the given ContainerPtr with at index in this Howl card set, @@ -268,14 +268,14 @@ private: ContainerPtr at(EntryCountType index) const; - ContainerPtr const* buckets() const; + Atomic const* buckets() const; public: G1CardSetHowl(EntryCountType card_in_region, G1CardSetConfiguration* config); - ContainerPtr const* container_addr(EntryCountType index) const; + Atomic const* container_addr(EntryCountType index) const; - ContainerPtr* container_addr(EntryCountType index); + Atomic* container_addr(EntryCountType index); bool contains(uint card_idx, G1CardSetConfiguration* config); // Iterates over all ContainerPtrs in this Howl card set, applying a CardOrRangeVisitor diff --git a/src/hotspot/share/gc/g1/g1CardSetContainers.inline.hpp b/src/hotspot/share/gc/g1/g1CardSetContainers.inline.hpp index 1958309f517..3c6fb9d1a02 100644 --- a/src/hotspot/share/gc/g1/g1CardSetContainers.inline.hpp +++ b/src/hotspot/share/gc/g1/g1CardSetContainers.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -67,7 +67,7 @@ inline G1AddCardResult G1CardSetInlinePtr::add(uint card_idx, uint bits_per_card return Overflow; } ContainerPtr new_value = merge(_value, card_idx, num_cards, bits_per_card); - ContainerPtr old_value = AtomicAccess::cmpxchg(_value_addr, _value, new_value, memory_order_relaxed); + ContainerPtr old_value = _value_addr->compare_exchange(_value, new_value, memory_order_relaxed); if (_value == old_value) { return Added; } @@ -126,7 +126,7 @@ inline bool G1CardSetContainer::try_increment_refcount() { } uintptr_t new_value = old_value + 2; - uintptr_t ref_count = AtomicAccess::cmpxchg(&_ref_count, old_value, new_value); + uintptr_t ref_count = _ref_count.compare_exchange(old_value, new_value); if (ref_count == old_value) { return true; } @@ -137,7 +137,7 @@ inline bool G1CardSetContainer::try_increment_refcount() { inline uintptr_t G1CardSetContainer::decrement_refcount() { uintptr_t old_value = refcount(); assert((old_value & 0x1) != 0 && old_value >= 3, "precondition"); - return AtomicAccess::sub(&_ref_count, 2u); + return _ref_count.sub_then_fetch(2u); } inline G1CardSetArray::G1CardSetArray(uint card_in_region, EntryCountType num_cards) : @@ -149,14 +149,13 @@ inline G1CardSetArray::G1CardSetArray(uint card_in_region, EntryCountType num_ca *entry_addr(0) = checked_cast(card_in_region); } -inline G1CardSetArray::G1CardSetArrayLocker::G1CardSetArrayLocker(EntryCountType volatile* num_entries_addr) : +inline G1CardSetArray::G1CardSetArrayLocker::G1CardSetArrayLocker(Atomic* num_entries_addr) : _num_entries_addr(num_entries_addr) { SpinYield s; - EntryCountType num_entries = AtomicAccess::load(_num_entries_addr) & EntryMask; + EntryCountType num_entries = _num_entries_addr->load_relaxed() & EntryMask; while (true) { - EntryCountType old_value = AtomicAccess::cmpxchg(_num_entries_addr, - num_entries, - (EntryCountType)(num_entries | LockBitMask)); + EntryCountType old_value = _num_entries_addr->compare_exchange(num_entries, + (EntryCountType)(num_entries | LockBitMask)); if (old_value == num_entries) { // Succeeded locking the array. _local_num_entries = num_entries; @@ -174,7 +173,7 @@ inline G1CardSetArray::EntryDataType const* G1CardSetArray::base_addr() const { } inline G1CardSetArray::EntryDataType const* G1CardSetArray::entry_addr(EntryCountType index) const { - assert(index < _num_entries, "precondition"); + assert(index < _num_entries.load_relaxed(), "precondition"); return base_addr() + index; } @@ -189,7 +188,7 @@ inline G1CardSetArray::EntryDataType G1CardSetArray::at(EntryCountType index) co inline G1AddCardResult G1CardSetArray::add(uint card_idx) { assert(card_idx < (1u << (sizeof(EntryDataType) * BitsPerByte)), "Card index %u does not fit allowed card value range.", card_idx); - EntryCountType num_entries = AtomicAccess::load_acquire(&_num_entries) & EntryMask; + EntryCountType num_entries = _num_entries.load_acquire() & EntryMask; EntryCountType idx = 0; for (; idx < num_entries; idx++) { if (at(idx) == card_idx) { @@ -223,7 +222,7 @@ inline G1AddCardResult G1CardSetArray::add(uint card_idx) { } inline bool G1CardSetArray::contains(uint card_idx) { - EntryCountType num_entries = AtomicAccess::load_acquire(&_num_entries) & EntryMask; + EntryCountType num_entries = _num_entries.load_acquire() & EntryMask; for (EntryCountType idx = 0; idx < num_entries; idx++) { if (at(idx) == card_idx) { @@ -235,7 +234,7 @@ inline bool G1CardSetArray::contains(uint card_idx) { template void G1CardSetArray::iterate(CardVisitor& found) { - EntryCountType num_entries = AtomicAccess::load_acquire(&_num_entries) & EntryMask; + EntryCountType num_entries = _num_entries.load_acquire() & EntryMask; for (EntryCountType idx = 0; idx < num_entries; idx++) { found(at(idx)); } @@ -256,11 +255,11 @@ inline G1CardSetBitMap::G1CardSetBitMap(uint card_in_region, uint size_in_bits) inline G1AddCardResult G1CardSetBitMap::add(uint card_idx, size_t threshold, size_t size_in_bits) { BitMapView bm(_bits, size_in_bits); - if (_num_bits_set >= threshold) { + if (_num_bits_set.load_relaxed() >= threshold) { return bm.at(card_idx) ? Found : Overflow; } if (bm.par_set_bit(card_idx)) { - AtomicAccess::inc(&_num_bits_set, memory_order_relaxed); + _num_bits_set.add_then_fetch(1u, memory_order_relaxed); return Added; } return Found; @@ -276,22 +275,22 @@ inline size_t G1CardSetBitMap::header_size_in_bytes() { return offset_of(G1CardSetBitMap, _bits); } -inline G1CardSetHowl::ContainerPtr const* G1CardSetHowl::container_addr(EntryCountType index) const { - assert(index < _num_entries, "precondition"); +inline Atomic const* G1CardSetHowl::container_addr(EntryCountType index) const { + assert(index < _num_entries.load_relaxed(), "precondition"); return buckets() + index; } -inline G1CardSetHowl::ContainerPtr* G1CardSetHowl::container_addr(EntryCountType index) { - return const_cast(const_cast(this)->container_addr(index)); +inline Atomic* G1CardSetHowl::container_addr(EntryCountType index) { + return const_cast*>(const_cast(this)->container_addr(index)); } inline G1CardSetHowl::ContainerPtr G1CardSetHowl::at(EntryCountType index) const { - return *container_addr(index); + return (*container_addr(index)).load_relaxed(); } -inline G1CardSetHowl::ContainerPtr const* G1CardSetHowl::buckets() const { +inline Atomic const* G1CardSetHowl::buckets() const { const void* ptr = reinterpret_cast(this) + header_size_in_bytes(); - return reinterpret_cast(ptr); + return reinterpret_cast const*>(ptr); } inline G1CardSetHowl::G1CardSetHowl(EntryCountType card_in_region, G1CardSetConfiguration* config) : @@ -300,7 +299,7 @@ inline G1CardSetHowl::G1CardSetHowl(EntryCountType card_in_region, G1CardSetConf EntryCountType num_buckets = config->num_buckets_in_howl(); EntryCountType bucket = config->howl_bucket_index(card_in_region); for (uint i = 0; i < num_buckets; ++i) { - *container_addr(i) = G1CardSetInlinePtr(); + container_addr(i)->store_relaxed(G1CardSetInlinePtr()); if (i == bucket) { G1CardSetInlinePtr value(container_addr(i), at(i)); value.add(card_in_region, config->inline_ptr_bits_per_card(), config->max_cards_in_inline_ptr()); @@ -310,8 +309,8 @@ inline G1CardSetHowl::G1CardSetHowl(EntryCountType card_in_region, G1CardSetConf inline bool G1CardSetHowl::contains(uint card_idx, G1CardSetConfiguration* config) { EntryCountType bucket = config->howl_bucket_index(card_idx); - ContainerPtr* array_entry = container_addr(bucket); - ContainerPtr container = AtomicAccess::load_acquire(array_entry); + Atomic* array_entry = container_addr(bucket); + ContainerPtr container = array_entry->load_acquire(); switch (G1CardSet::container_type(container)) { case G1CardSet::ContainerArrayOfCards: { diff --git a/src/hotspot/share/gc/g1/g1CardSetMemory.cpp b/src/hotspot/share/gc/g1/g1CardSetMemory.cpp index d13a6fe2dca..60602ef942b 100644 --- a/src/hotspot/share/gc/g1/g1CardSetMemory.cpp +++ b/src/hotspot/share/gc/g1/g1CardSetMemory.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -26,7 +26,6 @@ #include "gc/g1/g1CardSetContainers.inline.hpp" #include "gc/g1/g1CardSetMemory.inline.hpp" #include "gc/g1/g1MonotonicArena.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/ostream.hpp" G1CardSetAllocator::G1CardSetAllocator(const char* name, diff --git a/test/hotspot/gtest/gc/g1/test_g1CardSetContainers.cpp b/test/hotspot/gtest/gc/g1/test_g1CardSetContainers.cpp index d83d8ffeef6..91951b35405 100644 --- a/test/hotspot/gtest/gc/g1/test_g1CardSetContainers.cpp +++ b/test/hotspot/gtest/gc/g1/test_g1CardSetContainers.cpp @@ -25,6 +25,7 @@ #include "gc/g1/g1HeapRegionBounds.inline.hpp" #include "gc/shared/cardTable.hpp" #include "memory/allocation.inline.hpp" +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/powerOfTwo.hpp" #include "unittest.hpp" @@ -82,48 +83,48 @@ void G1CardSetContainersTest::cardset_inlineptr_test(uint bits_per_card) { G1AddCardResult res; - G1CardSet::ContainerPtr value = G1CardSetInlinePtr(); + Atomic value{}; for (uint i = 0; i < CardsPerSet; i++) { { - G1CardSetInlinePtr cards(&value, value); + G1CardSetInlinePtr cards(&value, value.load_relaxed()); res = cards.add(i + 1, bits_per_card, CardsPerSet); ASSERT_TRUE(res == Added); } { - G1CardSetInlinePtr cards(&value, value); + G1CardSetInlinePtr cards(&value, value.load_relaxed()); ASSERT_TRUE(cards.contains(i + 1, bits_per_card)); } } for (uint i = 0; i < CardsPerSet; i++) { - G1CardSetInlinePtr cards(value); + G1CardSetInlinePtr cards(value.load_relaxed()); ASSERT_TRUE(cards.contains(i + 1, bits_per_card)); } // Try to add again, should all return that the card had been added. for (uint i = 0; i < CardsPerSet; i++) { - G1CardSetInlinePtr cards(&value, value); + G1CardSetInlinePtr cards(&value, value.load_relaxed()); res = cards.add(i + 1, bits_per_card, CardsPerSet); ASSERT_TRUE(res == Found); } // Should be no more space in set. { - G1CardSetInlinePtr cards(&value, value); + G1CardSetInlinePtr cards(&value, value.load_relaxed()); res = cards.add(CardsPerSet + 1, bits_per_card, CardsPerSet); ASSERT_TRUE(res == Overflow); } // Cards should still be in the set. for (uint i = 0; i < CardsPerSet; i++) { - G1CardSetInlinePtr cards(value); + G1CardSetInlinePtr cards(value.load_relaxed()); ASSERT_TRUE(cards.contains(i + 1, bits_per_card)); } // Boundary cards should not be in the set. { - G1CardSetInlinePtr cards(value); + G1CardSetInlinePtr cards(value.load_relaxed()); ASSERT_TRUE(!cards.contains(0, bits_per_card)); ASSERT_TRUE(!cards.contains(CardsPerSet + 1, bits_per_card)); } @@ -131,7 +132,7 @@ void G1CardSetContainersTest::cardset_inlineptr_test(uint bits_per_card) { // Verify iteration finds all cards too and only those. { G1FindCardsInRange found(1, CardsPerSet); - G1CardSetInlinePtr cards(value); + G1CardSetInlinePtr cards(value.load_relaxed()); cards.iterate(found, bits_per_card); found.verify_all_found(); } From e7cadd90b2872364443873aa4b4b4664bcf02f4d Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:15:32 +0000 Subject: [PATCH 036/105] 8375981: G1: Convert G1RemSet helper classes to use Atomic Reviewed-by: shade, iwalulya --- src/hotspot/share/gc/g1/g1RemSet.cpp | 50 ++++++++++++++++------------ 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1RemSet.cpp b/src/hotspot/share/gc/g1/g1RemSet.cpp index c7724de280f..0c9a0fad8f2 100644 --- a/src/hotspot/share/gc/g1/g1RemSet.cpp +++ b/src/hotspot/share/gc/g1/g1RemSet.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2026, 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 @@ -50,7 +50,7 @@ #include "memory/resourceArea.hpp" #include "oops/access.inline.hpp" #include "oops/oop.inline.hpp" -#include "runtime/atomicAccess.hpp" +#include "runtime/atomic.hpp" #include "runtime/os.hpp" #include "utilities/align.hpp" #include "utilities/globalDefinitions.hpp" @@ -107,46 +107,48 @@ class G1RemSetScanState : public CHeapObj { // Set of (unique) regions that can be added to concurrently. class G1DirtyRegions : public CHeapObj { uint* _buffer; - uint _cur_idx; + Atomic _cur_idx; size_t _max_reserved_regions; - bool* _contains; + Atomic* _contains; public: G1DirtyRegions(size_t max_reserved_regions) : _buffer(NEW_C_HEAP_ARRAY(uint, max_reserved_regions, mtGC)), _cur_idx(0), _max_reserved_regions(max_reserved_regions), - _contains(NEW_C_HEAP_ARRAY(bool, max_reserved_regions, mtGC)) { + _contains(NEW_C_HEAP_ARRAY(Atomic, max_reserved_regions, mtGC)) { reset(); } ~G1DirtyRegions() { FREE_C_HEAP_ARRAY(uint, _buffer); - FREE_C_HEAP_ARRAY(bool, _contains); + FREE_C_HEAP_ARRAY(Atomic, _contains); } void reset() { - _cur_idx = 0; - ::memset(_contains, false, _max_reserved_regions * sizeof(bool)); + _cur_idx.store_relaxed(0); + for (uint i = 0; i < _max_reserved_regions; i++) { + _contains[i].store_relaxed(false); + } } - uint size() const { return _cur_idx; } + uint size() const { return _cur_idx.load_relaxed(); } uint at(uint idx) const { - assert(idx < _cur_idx, "Index %u beyond valid regions", idx); + assert(idx < size(), "Index %u beyond valid regions", idx); return _buffer[idx]; } void add_dirty_region(uint region) { - if (_contains[region]) { + if (_contains[region].load_relaxed()) { return; } - bool marked_as_dirty = AtomicAccess::cmpxchg(&_contains[region], false, true) == false; + bool marked_as_dirty = _contains[region].compare_set(false, true); if (marked_as_dirty) { - uint allocated = AtomicAccess::fetch_then_add(&_cur_idx, 1u); + uint allocated = _cur_idx.fetch_then_add(1u); _buffer[allocated] = region; } } @@ -155,9 +157,11 @@ class G1RemSetScanState : public CHeapObj { void merge(const G1DirtyRegions* other) { for (uint i = 0; i < other->size(); i++) { uint region = other->at(i); - if (!_contains[region]) { - _buffer[_cur_idx++] = region; - _contains[region] = true; + if (!_contains[region].load_relaxed()) { + uint cur = _cur_idx.load_relaxed(); + _buffer[cur] = region; + _cur_idx.store_relaxed(cur + 1); + _contains[region].store_relaxed(true); } } } @@ -173,7 +177,7 @@ class G1RemSetScanState : public CHeapObj { class G1ClearCardTableTask : public G1AbstractSubTask { G1CollectedHeap* _g1h; G1DirtyRegions* _regions; - uint volatile _cur_dirty_regions; + Atomic _cur_dirty_regions; G1RemSetScanState* _scan_state; @@ -210,8 +214,9 @@ class G1ClearCardTableTask : public G1AbstractSubTask { void do_work(uint worker_id) override { const uint num_regions_per_worker = num_cards_per_worker / (uint)G1HeapRegion::CardsPerRegion; - while (_cur_dirty_regions < _regions->size()) { - uint next = AtomicAccess::fetch_then_add(&_cur_dirty_regions, num_regions_per_worker); + uint cur = _cur_dirty_regions.load_relaxed(); + while (cur < _regions->size()) { + uint next = _cur_dirty_regions.fetch_then_add(num_regions_per_worker); uint max = MIN2(next + num_regions_per_worker, _regions->size()); for (uint i = next; i < max; i++) { @@ -226,6 +231,7 @@ class G1ClearCardTableTask : public G1AbstractSubTask { // old regions use it for old->collection set candidates, so they should not be cleared // either. } + cur = max; } } }; @@ -1115,7 +1121,7 @@ class G1MergeHeapRootsTask : public WorkerTask { bool _initial_evacuation; - volatile bool _fast_reclaim_handled; + Atomic _fast_reclaim_handled; public: G1MergeHeapRootsTask(G1RemSetScanState* scan_state, uint num_workers, bool initial_evacuation) : @@ -1143,8 +1149,8 @@ public: // 1. eager-reclaim candidates if (_initial_evacuation && g1h->has_humongous_reclaim_candidates() && - !_fast_reclaim_handled && - !AtomicAccess::cmpxchg(&_fast_reclaim_handled, false, true)) { + !_fast_reclaim_handled.load_relaxed() && + _fast_reclaim_handled.compare_set(false, true)) { G1GCParPhaseTimesTracker subphase_x(p, G1GCPhaseTimes::MergeER, worker_id); From 4597046984dedfd28bd76bd00dfc4b13ccb38dd4 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:16:11 +0000 Subject: [PATCH 037/105] 8375974: G1: Convert G1FullCollector to use Atomic Reviewed-by: kbarrett, iwalulya --- src/hotspot/share/gc/g1/g1FullCollector.cpp | 6 +++--- src/hotspot/share/gc/g1/g1FullCollector.hpp | 2 +- src/hotspot/share/gc/g1/g1FullCollector.inline.hpp | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1FullCollector.cpp b/src/hotspot/share/gc/g1/g1FullCollector.cpp index 7395df01760..6c8cc7028cc 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.cpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.cpp @@ -134,10 +134,10 @@ G1FullCollector::G1FullCollector(G1CollectedHeap* heap, _compaction_points = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC); _live_stats = NEW_C_HEAP_ARRAY(G1RegionMarkStats, _heap->max_num_regions(), mtGC); - _compaction_tops = NEW_C_HEAP_ARRAY(HeapWord*, _heap->max_num_regions(), mtGC); + _compaction_tops = NEW_C_HEAP_ARRAY(Atomic, _heap->max_num_regions(), mtGC); for (uint j = 0; j < heap->max_num_regions(); j++) { _live_stats[j].clear(); - _compaction_tops[j] = nullptr; + ::new (&_compaction_tops[j]) Atomic{}; } _partial_array_state_manager = new PartialArrayStateManager(_num_workers); @@ -167,7 +167,7 @@ G1FullCollector::~G1FullCollector() { FREE_C_HEAP_ARRAY(G1FullGCMarker*, _markers); FREE_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _compaction_points); - FREE_C_HEAP_ARRAY(HeapWord*, _compaction_tops); + FREE_C_HEAP_ARRAY(Atomic, _compaction_tops); FREE_C_HEAP_ARRAY(G1RegionMarkStats, _live_stats); } diff --git a/src/hotspot/share/gc/g1/g1FullCollector.hpp b/src/hotspot/share/gc/g1/g1FullCollector.hpp index 28ecffad944..7e455b07013 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.hpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.hpp @@ -96,7 +96,7 @@ class G1FullCollector : StackObj { G1FullGCHeapRegionAttr _region_attr_table; - HeapWord* volatile* _compaction_tops; + Atomic* _compaction_tops; public: G1FullCollector(G1CollectedHeap* heap, diff --git a/src/hotspot/share/gc/g1/g1FullCollector.inline.hpp b/src/hotspot/share/gc/g1/g1FullCollector.inline.hpp index b52f3d79604..0c201f0e43f 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.inline.hpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -63,11 +63,11 @@ void G1FullCollector::update_from_skip_compacting_to_compacting(uint region_idx) } void G1FullCollector::set_compaction_top(G1HeapRegion* r, HeapWord* value) { - AtomicAccess::store(&_compaction_tops[r->hrm_index()], value); + _compaction_tops[r->hrm_index()].store_relaxed(value); } HeapWord* G1FullCollector::compaction_top(G1HeapRegion* r) const { - return AtomicAccess::load(&_compaction_tops[r->hrm_index()]); + return _compaction_tops[r->hrm_index()].load_relaxed(); } void G1FullCollector::set_has_compaction_targets() { From a49986c62f4bcc4656f4ce0c7804a96875e9b6c6 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:16:41 +0000 Subject: [PATCH 038/105] 8375964: G1: Convert G1BuildCandidateRegionsTask to use Atomic Reviewed-by: shade, iwalulya --- src/hotspot/share/gc/g1/g1CollectionSetChooser.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1CollectionSetChooser.cpp b/src/hotspot/share/gc/g1/g1CollectionSetChooser.cpp index d9496410c12..e7bab32129e 100644 --- a/src/hotspot/share/gc/g1/g1CollectionSetChooser.cpp +++ b/src/hotspot/share/gc/g1/g1CollectionSetChooser.cpp @@ -203,13 +203,13 @@ class G1BuildCandidateRegionsTask : public WorkerTask { G1CollectedHeap* _g1h; G1HeapRegionClaimer _hrclaimer; - uint volatile _num_regions_added; + Atomic _num_regions_added; G1BuildCandidateArray _result; void update_totals(uint num_regions) { if (num_regions > 0) { - AtomicAccess::add(&_num_regions_added, num_regions); + _num_regions_added.add_then_fetch(num_regions); } } @@ -221,7 +221,7 @@ class G1BuildCandidateRegionsTask : public WorkerTask { void prune(G1HeapRegion** data) { G1Policy* p = G1CollectedHeap::heap()->policy(); - uint num_candidates = AtomicAccess::load(&_num_regions_added); + uint num_candidates = _num_regions_added.load_relaxed(); uint min_old_cset_length = p->calc_min_old_cset_length(num_candidates); uint num_pruned = 0; @@ -254,7 +254,7 @@ class G1BuildCandidateRegionsTask : public WorkerTask { wasted_bytes, allowed_waste); - AtomicAccess::sub(&_num_regions_added, num_pruned, memory_order_relaxed); + _num_regions_added.sub_then_fetch(num_pruned, memory_order_relaxed); } public: @@ -275,7 +275,7 @@ public: _result.sort_by_gc_efficiency(); prune(_result.array()); candidates->set_candidates_from_marking(_result.array(), - _num_regions_added); + _num_regions_added.load_relaxed()); } }; From c3360ff51155bdd62b758c163351f57f4b410606 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:17:01 +0000 Subject: [PATCH 039/105] 8375983: G1: Convert G1ConcurrentRefineStats to use Atomic Reviewed-by: kbarrett, iwalulya --- .../share/gc/g1/g1ConcurrentRefine.cpp | 1 + .../share/gc/g1/g1ConcurrentRefineStats.cpp | 32 +++-- .../share/gc/g1/g1ConcurrentRefineStats.hpp | 68 +++++----- .../gc/g1/g1ConcurrentRefineStats.inline.hpp | 118 ++++++++++++++++++ .../gc/g1/g1ConcurrentRefineSweepTask.cpp | 1 + .../gc/g1/g1ConcurrentRefineSweepTask.hpp | 2 +- .../share/gc/g1/g1ConcurrentRefineThread.cpp | 2 +- .../share/gc/g1/g1ConcurrentRefineThread.hpp | 1 - src/hotspot/share/gc/g1/g1Policy.cpp | 2 +- .../share/gc/g1/g1YoungGCPreEvacuateTasks.cpp | 1 - 10 files changed, 177 insertions(+), 51 deletions(-) create mode 100644 src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp b/src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp index ed6a9ad4292..8546e6e2d64 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp @@ -28,6 +28,7 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectionSet.hpp" #include "gc/g1/g1ConcurrentRefine.hpp" +#include "gc/g1/g1ConcurrentRefineStats.inline.hpp" #include "gc/g1/g1ConcurrentRefineSweepTask.hpp" #include "gc/g1/g1ConcurrentRefineThread.hpp" #include "gc/g1/g1HeapRegion.inline.hpp" diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp index 83a09c55a3f..5160d5ed036 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -22,7 +22,7 @@ * */ -#include "gc/g1/g1ConcurrentRefineStats.hpp" +#include "gc/g1/g1ConcurrentRefineStats.inline.hpp" #include "runtime/atomicAccess.hpp" #include "runtime/timer.hpp" @@ -39,19 +39,27 @@ G1ConcurrentRefineStats::G1ConcurrentRefineStats() : {} void G1ConcurrentRefineStats::add_atomic(G1ConcurrentRefineStats* other) { - AtomicAccess::add(&_sweep_duration, other->_sweep_duration, memory_order_relaxed); - AtomicAccess::add(&_yield_during_sweep_duration, other->_yield_during_sweep_duration, memory_order_relaxed); + _sweep_duration.add_then_fetch(other->_sweep_duration.load_relaxed(), memory_order_relaxed); + _yield_during_sweep_duration.add_then_fetch(other->yield_during_sweep_duration(), memory_order_relaxed); - AtomicAccess::add(&_cards_scanned, other->_cards_scanned, memory_order_relaxed); - AtomicAccess::add(&_cards_clean, other->_cards_clean, memory_order_relaxed); - AtomicAccess::add(&_cards_not_parsable, other->_cards_not_parsable, memory_order_relaxed); - AtomicAccess::add(&_cards_already_refer_to_cset, other->_cards_already_refer_to_cset, memory_order_relaxed); - AtomicAccess::add(&_cards_refer_to_cset, other->_cards_refer_to_cset, memory_order_relaxed); - AtomicAccess::add(&_cards_no_cross_region, other->_cards_no_cross_region, memory_order_relaxed); + _cards_scanned.add_then_fetch(other->cards_scanned(), memory_order_relaxed); + _cards_clean.add_then_fetch(other->cards_clean(), memory_order_relaxed); + _cards_not_parsable.add_then_fetch(other->cards_not_parsable(), memory_order_relaxed); + _cards_already_refer_to_cset.add_then_fetch(other->cards_already_refer_to_cset(), memory_order_relaxed); + _cards_refer_to_cset.add_then_fetch(other->cards_refer_to_cset(), memory_order_relaxed); + _cards_no_cross_region.add_then_fetch(other->cards_no_cross_region(), memory_order_relaxed); - AtomicAccess::add(&_refine_duration, other->_refine_duration, memory_order_relaxed); + _refine_duration.add_then_fetch(other->refine_duration(), memory_order_relaxed); } void G1ConcurrentRefineStats::reset() { - *this = G1ConcurrentRefineStats(); + _sweep_duration.store_relaxed(0); + _yield_during_sweep_duration.store_relaxed(0); + _cards_scanned.store_relaxed(0); + _cards_clean.store_relaxed(0); + _cards_not_parsable.store_relaxed(0); + _cards_already_refer_to_cset.store_relaxed(0); + _cards_refer_to_cset.store_relaxed(0); + _cards_no_cross_region.store_relaxed(0); + _refine_duration.store_relaxed(0); } diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp index ce22f4317df..5f57c56ba6c 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -26,61 +26,61 @@ #define SHARE_GC_G1_G1CONCURRENTREFINESTATS_HPP #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" -#include "utilities/ticks.hpp" // Collection of statistics for concurrent refinement processing. // Used for collecting per-thread statistics and for summaries over a // collection of threads. class G1ConcurrentRefineStats : public CHeapObj { - jlong _sweep_duration; // Time spent sweeping the table finding non-clean cards - // and refining them. - jlong _yield_during_sweep_duration; // Time spent yielding during the sweep (not doing the sweep). + Atomic _sweep_duration; // Time spent sweeping the table finding non-clean cards + // and refining them. + Atomic _yield_during_sweep_duration; // Time spent yielding during the sweep (not doing the sweep). - size_t _cards_scanned; // Total number of cards scanned. - size_t _cards_clean; // Number of cards found clean. - size_t _cards_not_parsable; // Number of cards we could not parse and left unrefined. - size_t _cards_already_refer_to_cset;// Number of cards marked found to be already young. - size_t _cards_refer_to_cset; // Number of dirty cards that were recently found to contain a to-cset reference. - size_t _cards_no_cross_region; // Number of dirty cards that were dirtied, but then cleaned again by the mutator. + Atomic _cards_scanned; // Total number of cards scanned. + Atomic _cards_clean; // Number of cards found clean. + Atomic _cards_not_parsable; // Number of cards we could not parse and left unrefined. + Atomic _cards_already_refer_to_cset;// Number of cards marked found to be already young. + Atomic _cards_refer_to_cset; // Number of dirty cards that were recently found to contain a to-cset reference. + Atomic _cards_no_cross_region; // Number of dirty cards that were dirtied, but then cleaned again by the mutator. - jlong _refine_duration; // Time spent during actual refinement. + Atomic _refine_duration; // Time spent during actual refinement. public: G1ConcurrentRefineStats(); // Time spent performing sweeping the refinement table (includes actual refinement, // but not yield time). - jlong sweep_duration() const { return _sweep_duration - _yield_during_sweep_duration; } - jlong yield_during_sweep_duration() const { return _yield_during_sweep_duration; } - jlong refine_duration() const { return _refine_duration; } + inline jlong sweep_duration() const; + inline jlong yield_during_sweep_duration() const; + inline jlong refine_duration() const; // Number of refined cards. - size_t refined_cards() const { return cards_not_clean(); } + inline size_t refined_cards() const; - size_t cards_scanned() const { return _cards_scanned; } - size_t cards_clean() const { return _cards_clean; } - size_t cards_not_clean() const { return _cards_scanned - _cards_clean; } - size_t cards_not_parsable() const { return _cards_not_parsable; } - size_t cards_already_refer_to_cset() const { return _cards_already_refer_to_cset; } - size_t cards_refer_to_cset() const { return _cards_refer_to_cset; } - size_t cards_no_cross_region() const { return _cards_no_cross_region; } + inline size_t cards_scanned() const; + inline size_t cards_clean() const; + inline size_t cards_not_clean() const; + inline size_t cards_not_parsable() const; + inline size_t cards_already_refer_to_cset() const; + inline size_t cards_refer_to_cset() const; + inline size_t cards_no_cross_region() const; // Number of cards that were marked dirty and in need of refinement. This includes cards recently // found to refer to the collection set as they originally were dirty. - size_t cards_pending() const { return cards_not_clean() - _cards_already_refer_to_cset; } + inline size_t cards_pending() const; - size_t cards_to_cset() const { return _cards_already_refer_to_cset + _cards_refer_to_cset; } + inline size_t cards_to_cset() const; - void inc_sweep_time(jlong t) { _sweep_duration += t; } - void inc_yield_during_sweep_duration(jlong t) { _yield_during_sweep_duration += t; } - void inc_refine_duration(jlong t) { _refine_duration += t; } + inline void inc_sweep_time(jlong t); + inline void inc_yield_during_sweep_duration(jlong t); + inline void inc_refine_duration(jlong t); - void inc_cards_scanned(size_t increment) { _cards_scanned += increment; } - void inc_cards_clean(size_t increment) { _cards_clean += increment; } - void inc_cards_not_parsable() { _cards_not_parsable++; } - void inc_cards_already_refer_to_cset() { _cards_already_refer_to_cset++; } - void inc_cards_refer_to_cset() { _cards_refer_to_cset++; } - void inc_cards_no_cross_region() { _cards_no_cross_region++; } + inline void inc_cards_scanned(size_t increment); + inline void inc_cards_clean(size_t increment); + inline void inc_cards_not_parsable(); + inline void inc_cards_already_refer_to_cset(); + inline void inc_cards_refer_to_cset(); + inline void inc_cards_no_cross_region(); void add_atomic(G1ConcurrentRefineStats* other); diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp new file mode 100644 index 00000000000..5460dc35bba --- /dev/null +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2026, 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.inline 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. + * + */ + +#ifndef SHARE_GC_G1_G1CONCURRENTREFINESTATS_INLINE_HPP +#define SHARE_GC_G1_G1CONCURRENTREFINESTATS_INLINE_HPP + +#include "gc/g1/g1ConcurrentRefineStats.hpp" + +inline jlong G1ConcurrentRefineStats::sweep_duration() const { + return _sweep_duration.load_relaxed() - yield_during_sweep_duration(); +} + +inline jlong G1ConcurrentRefineStats::yield_during_sweep_duration() const { + return _yield_during_sweep_duration.load_relaxed(); +} + +inline jlong G1ConcurrentRefineStats::refine_duration() const { + return _refine_duration.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::refined_cards() const { + return cards_not_clean(); +} + +inline size_t G1ConcurrentRefineStats::cards_scanned() const { + return _cards_scanned.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_clean() const { + return _cards_clean.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_not_clean() const { + return cards_scanned() - cards_clean(); +} + +inline size_t G1ConcurrentRefineStats::cards_not_parsable() const { + return _cards_not_parsable.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_already_refer_to_cset() const { + return _cards_already_refer_to_cset.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_refer_to_cset() const { + return _cards_refer_to_cset.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_no_cross_region() const { + return _cards_no_cross_region.load_relaxed(); +} + +inline size_t G1ConcurrentRefineStats::cards_pending() const { + return cards_not_clean() - cards_already_refer_to_cset(); +} + +inline size_t G1ConcurrentRefineStats::cards_to_cset() const { + return cards_already_refer_to_cset() + cards_refer_to_cset(); +} + +inline void G1ConcurrentRefineStats::inc_sweep_time(jlong t) { + _sweep_duration.store_relaxed(_sweep_duration.load_relaxed() + t); +} + +inline void G1ConcurrentRefineStats::inc_yield_during_sweep_duration(jlong t) { + _yield_during_sweep_duration.store_relaxed(yield_during_sweep_duration() + t); +} + +inline void G1ConcurrentRefineStats::inc_refine_duration(jlong t) { + _refine_duration.store_relaxed(refine_duration() + t); +} + +inline void G1ConcurrentRefineStats::inc_cards_scanned(size_t increment) { + _cards_scanned.store_relaxed(cards_scanned() + increment); +} + +inline void G1ConcurrentRefineStats::inc_cards_clean(size_t increment) { + _cards_clean.store_relaxed(cards_clean() + increment); +} + +inline void G1ConcurrentRefineStats::inc_cards_not_parsable() { + _cards_not_parsable.store_relaxed(cards_not_parsable() + 1); +} + +inline void G1ConcurrentRefineStats::inc_cards_already_refer_to_cset() { + _cards_already_refer_to_cset.store_relaxed(cards_already_refer_to_cset() + 1); +} + +inline void G1ConcurrentRefineStats::inc_cards_refer_to_cset() { + _cards_refer_to_cset.store_relaxed(cards_refer_to_cset() + 1); +} + +inline void G1ConcurrentRefineStats::inc_cards_no_cross_region() { + _cards_no_cross_region.store_relaxed(cards_no_cross_region() + 1); +} + +#endif // SHARE_GC_G1_G1CONCURRENTREFINESTATS_INLINE_HPP diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.cpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.cpp index ca5bc9ebe5f..ce944f2254d 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.cpp @@ -24,6 +24,7 @@ #include "gc/g1/g1CardTableClaimTable.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" +#include "gc/g1/g1ConcurrentRefineStats.inline.hpp" #include "gc/g1/g1ConcurrentRefineSweepTask.hpp" class G1RefineRegionClosure : public G1HeapRegionClosure { diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.hpp index bf24c5ae850..827b9a3c402 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineSweepTask.hpp @@ -25,10 +25,10 @@ #ifndef SHARE_GC_G1_G1CONCURRENTREFINESWEEPTASK_HPP #define SHARE_GC_G1_G1CONCURRENTREFINESWEEPTASK_HPP -#include "gc/g1/g1ConcurrentRefineStats.hpp" #include "gc/shared/workerThread.hpp" class G1CardTableClaimTable; +class G1ConcurrentRefineStats; class G1ConcurrentRefineSweepTask : public WorkerTask { G1CardTableClaimTable* _scan_state; diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp index eccfe466d48..6b51e5eef62 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp @@ -26,7 +26,7 @@ #include "gc/g1/g1CardTableClaimTable.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1ConcurrentRefine.hpp" -#include "gc/g1/g1ConcurrentRefineStats.hpp" +#include "gc/g1/g1ConcurrentRefineStats.inline.hpp" #include "gc/g1/g1ConcurrentRefineSweepTask.hpp" #include "gc/g1/g1ConcurrentRefineThread.hpp" #include "gc/shared/gcTraceTime.inline.hpp" diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp index 7cdc001d348..2ecbdc668eb 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp @@ -25,7 +25,6 @@ #ifndef SHARE_GC_G1_G1CONCURRENTREFINETHREAD_HPP #define SHARE_GC_G1_G1CONCURRENTREFINETHREAD_HPP -#include "gc/g1/g1ConcurrentRefineStats.hpp" #include "gc/shared/concurrentGCThread.hpp" #include "runtime/mutex.hpp" #include "utilities/globalDefinitions.hpp" diff --git a/src/hotspot/share/gc/g1/g1Policy.cpp b/src/hotspot/share/gc/g1/g1Policy.cpp index 8818b477aae..1d0b29c303e 100644 --- a/src/hotspot/share/gc/g1/g1Policy.cpp +++ b/src/hotspot/share/gc/g1/g1Policy.cpp @@ -32,7 +32,7 @@ #include "gc/g1/g1ConcurrentMark.hpp" #include "gc/g1/g1ConcurrentMarkThread.inline.hpp" #include "gc/g1/g1ConcurrentRefine.hpp" -#include "gc/g1/g1ConcurrentRefineStats.hpp" +#include "gc/g1/g1ConcurrentRefineStats.inline.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" #include "gc/g1/g1HeapRegion.inline.hpp" #include "gc/g1/g1HeapRegionRemSet.inline.hpp" diff --git a/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp b/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp index b11213ddeb3..c0870b7a726 100644 --- a/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp +++ b/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp @@ -23,7 +23,6 @@ */ #include "gc/g1/g1CollectedHeap.inline.hpp" -#include "gc/g1/g1ConcurrentRefineStats.hpp" #include "gc/g1/g1RegionPinCache.inline.hpp" #include "gc/g1/g1ThreadLocalData.hpp" #include "gc/g1/g1YoungGCPreEvacuateTasks.hpp" From 0bc2dc3401f01b4727077a9844194d1654c3138c Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:17:22 +0000 Subject: [PATCH 040/105] 8375971: G1: Convert G1EvacStats to use Atomic Reviewed-by: iwalulya, kbarrett --- .../share/gc/g1/g1CollectedHeap.inline.hpp | 1 + src/hotspot/share/gc/g1/g1EvacStats.cpp | 31 ++++++++----- src/hotspot/share/gc/g1/g1EvacStats.hpp | 42 +++++++----------- .../share/gc/g1/g1EvacStats.inline.hpp | 44 +++++++++++++++---- 4 files changed, 74 insertions(+), 44 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.inline.hpp b/src/hotspot/share/gc/g1/g1CollectedHeap.inline.hpp index 958b171444e..8782b65b6f9 100644 --- a/src/hotspot/share/gc/g1/g1CollectedHeap.inline.hpp +++ b/src/hotspot/share/gc/g1/g1CollectedHeap.inline.hpp @@ -31,6 +31,7 @@ #include "gc/g1/g1CollectorState.hpp" #include "gc/g1/g1ConcurrentMark.inline.hpp" #include "gc/g1/g1EvacFailureRegions.hpp" +#include "gc/g1/g1EvacStats.inline.hpp" #include "gc/g1/g1HeapRegion.inline.hpp" #include "gc/g1/g1HeapRegionManager.inline.hpp" #include "gc/g1/g1HeapRegionRemSet.hpp" diff --git a/src/hotspot/share/gc/g1/g1EvacStats.cpp b/src/hotspot/share/gc/g1/g1EvacStats.cpp index 049175a4ecc..1d54b184e64 100644 --- a/src/hotspot/share/gc/g1/g1EvacStats.cpp +++ b/src/hotspot/share/gc/g1/g1EvacStats.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -22,13 +22,24 @@ * */ -#include "gc/g1/g1EvacStats.hpp" +#include "gc/g1/g1EvacStats.inline.hpp" #include "gc/shared/gc_globals.hpp" #include "gc/shared/gcId.hpp" #include "logging/log.hpp" #include "memory/allocation.inline.hpp" #include "runtime/globals.hpp" +void G1EvacStats::reset() { + PLABStats::reset(); + _region_end_waste.store_relaxed(0); + _regions_filled.store_relaxed(0); + _num_plab_filled.store_relaxed(0); + _direct_allocated.store_relaxed(0); + _num_direct_allocated.store_relaxed(0); + _failure_used.store_relaxed(0); + _failure_waste.store_relaxed(0); +} + void G1EvacStats::log_plab_allocation() { log_debug(gc, plab)("%s PLAB allocation: " "allocated: %zuB, " @@ -51,13 +62,13 @@ void G1EvacStats::log_plab_allocation() { "failure used: %zuB, " "failure wasted: %zuB", _description, - _region_end_waste * HeapWordSize, - _regions_filled, - _num_plab_filled, - _direct_allocated * HeapWordSize, - _num_direct_allocated, - _failure_used * HeapWordSize, - _failure_waste * HeapWordSize); + region_end_waste() * HeapWordSize, + regions_filled(), + num_plab_filled(), + direct_allocated() * HeapWordSize, + num_direct_allocated(), + failure_used() * HeapWordSize, + failure_waste() * HeapWordSize); } void G1EvacStats::log_sizing(size_t calculated_words, size_t net_desired_words) { @@ -109,7 +120,7 @@ size_t G1EvacStats::compute_desired_plab_size() const { // threads do not allocate anything but a few rather large objects. In this // degenerate case the PLAB size would simply quickly tend to minimum PLAB size, // which is an okay reaction. - size_t const used_for_waste_calculation = used() > _region_end_waste ? used() - _region_end_waste : 0; + size_t const used_for_waste_calculation = used() > region_end_waste() ? used() - region_end_waste() : 0; size_t const total_waste_allowed = used_for_waste_calculation * TargetPLABWastePct; return (size_t)((double)total_waste_allowed / (100 - G1LastPLABAverageOccupancy)); diff --git a/src/hotspot/share/gc/g1/g1EvacStats.hpp b/src/hotspot/share/gc/g1/g1EvacStats.hpp index e6eb80442d6..b250d4580b5 100644 --- a/src/hotspot/share/gc/g1/g1EvacStats.hpp +++ b/src/hotspot/share/gc/g1/g1EvacStats.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -27,6 +27,7 @@ #include "gc/shared/gcUtil.hpp" #include "gc/shared/plab.hpp" +#include "runtime/atomic.hpp" // Records various memory allocation statistics gathered during evacuation. All sizes // are in HeapWords. @@ -36,30 +37,21 @@ class G1EvacStats : public PLABStats { AdaptiveWeightedAverage _net_plab_size_filter; // Integrator with decay - size_t _region_end_waste; // Number of words wasted due to skipping to the next region. - uint _regions_filled; // Number of regions filled completely. - size_t _num_plab_filled; // Number of PLABs filled and retired. - size_t _direct_allocated; // Number of words allocated directly into the regions. - size_t _num_direct_allocated; // Number of direct allocation attempts. + Atomic _region_end_waste; // Number of words wasted due to skipping to the next region. + Atomic _regions_filled; // Number of regions filled completely. + Atomic _num_plab_filled; // Number of PLABs filled and retired. + Atomic _direct_allocated; // Number of words allocated directly into the regions. + Atomic _num_direct_allocated; // Number of direct allocation attempts. // Number of words in live objects remaining in regions that ultimately suffered an // evacuation failure. This is used in the regions when the regions are made old regions. - size_t _failure_used; + Atomic _failure_used; // Number of words wasted in regions which failed evacuation. This is the sum of space // for objects successfully copied out of the regions (now dead space) plus waste at the // end of regions. - size_t _failure_waste; + Atomic _failure_waste; - virtual void reset() { - PLABStats::reset(); - _region_end_waste = 0; - _regions_filled = 0; - _num_plab_filled = 0; - _direct_allocated = 0; - _num_direct_allocated = 0; - _failure_used = 0; - _failure_waste = 0; - } + virtual void reset(); void log_plab_allocation(); void log_sizing(size_t calculated_words, size_t net_desired_words); @@ -77,16 +69,16 @@ public: // Should be called at the end of a GC pause. void adjust_desired_plab_size(); - uint regions_filled() const { return _regions_filled; } - size_t num_plab_filled() const { return _num_plab_filled; } - size_t region_end_waste() const { return _region_end_waste; } - size_t direct_allocated() const { return _direct_allocated; } - size_t num_direct_allocated() const { return _num_direct_allocated; } + uint regions_filled() const; + size_t num_plab_filled() const; + size_t region_end_waste() const; + size_t direct_allocated() const; + size_t num_direct_allocated() const; // Amount of space in heapwords used in the failing regions when an evacuation failure happens. - size_t failure_used() const { return _failure_used; } + size_t failure_used() const; // Amount of space in heapwords wasted (unused) in the failing regions when an evacuation failure happens. - size_t failure_waste() const { return _failure_waste; } + size_t failure_waste() const; inline void add_num_plab_filled(size_t value); inline void add_direct_allocated(size_t value); diff --git a/src/hotspot/share/gc/g1/g1EvacStats.inline.hpp b/src/hotspot/share/gc/g1/g1EvacStats.inline.hpp index c90598a30cb..2bd3b37719a 100644 --- a/src/hotspot/share/gc/g1/g1EvacStats.inline.hpp +++ b/src/hotspot/share/gc/g1/g1EvacStats.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -27,28 +27,54 @@ #include "gc/g1/g1EvacStats.hpp" -#include "runtime/atomicAccess.hpp" +inline uint G1EvacStats::regions_filled() const { + return _regions_filled.load_relaxed(); +} + +inline size_t G1EvacStats::num_plab_filled() const { + return _num_plab_filled.load_relaxed(); +} + +inline size_t G1EvacStats::region_end_waste() const { + return _region_end_waste.load_relaxed(); +} + +inline size_t G1EvacStats::direct_allocated() const { + return _direct_allocated.load_relaxed(); +} + +inline size_t G1EvacStats::num_direct_allocated() const { + return _num_direct_allocated.load_relaxed(); +} + +inline size_t G1EvacStats::failure_used() const { + return _failure_used.load_relaxed(); +} + +inline size_t G1EvacStats::failure_waste() const { + return _failure_waste.load_relaxed(); +} inline void G1EvacStats::add_direct_allocated(size_t value) { - AtomicAccess::add(&_direct_allocated, value, memory_order_relaxed); + _direct_allocated.add_then_fetch(value, memory_order_relaxed); } inline void G1EvacStats::add_num_plab_filled(size_t value) { - AtomicAccess::add(&_num_plab_filled, value, memory_order_relaxed); + _num_plab_filled.add_then_fetch(value, memory_order_relaxed); } inline void G1EvacStats::add_num_direct_allocated(size_t value) { - AtomicAccess::add(&_num_direct_allocated, value, memory_order_relaxed); + _num_direct_allocated.add_then_fetch(value, memory_order_relaxed); } inline void G1EvacStats::add_region_end_waste(size_t value) { - AtomicAccess::add(&_region_end_waste, value, memory_order_relaxed); - AtomicAccess::inc(&_regions_filled, memory_order_relaxed); + _region_end_waste.add_then_fetch(value, memory_order_relaxed); + _regions_filled.add_then_fetch(1u, memory_order_relaxed); } inline void G1EvacStats::add_failure_used_and_waste(size_t used, size_t waste) { - AtomicAccess::add(&_failure_used, used, memory_order_relaxed); - AtomicAccess::add(&_failure_waste, waste, memory_order_relaxed); + _failure_used.add_then_fetch(used, memory_order_relaxed); + _failure_waste.add_then_fetch(waste, memory_order_relaxed); } #endif // SHARE_GC_G1_G1EVACSTATS_INLINE_HPP From 90d065e677535e3f7caa7507f1526062b50ecc67 Mon Sep 17 00:00:00 2001 From: Jan Lahoda Date: Mon, 26 Jan 2026 09:42:49 +0000 Subject: [PATCH 041/105] 8375712: Convert java/lang/runtime tests to use JUnit Reviewed-by: liach --- .../ExactnessConversionsSupportTest.java | 54 ++-- .../java/lang/runtime/ObjectMethodsTest.java | 47 ++-- .../lang/runtime/SwitchBootstrapsTest.java | 251 +++++++----------- 3 files changed, 142 insertions(+), 210 deletions(-) diff --git a/test/jdk/java/lang/runtime/ExactnessConversionsSupportTest.java b/test/jdk/java/lang/runtime/ExactnessConversionsSupportTest.java index 6e1ef8e4c9f..3fbdfc5e9ab 100644 --- a/test/jdk/java/lang/runtime/ExactnessConversionsSupportTest.java +++ b/test/jdk/java/lang/runtime/ExactnessConversionsSupportTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, 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 @@ -21,46 +21,20 @@ * questions. */ -import org.testng.annotations.Test; - -import java.io.Serializable; -import java.lang.Enum.EnumDesc; -import java.lang.classfile.ClassFile; -import java.lang.constant.ClassDesc; -import java.lang.constant.ConstantDescs; -import java.lang.constant.MethodTypeDesc; -import java.lang.invoke.CallSite; -import java.lang.invoke.MethodHandle; -import java.lang.invoke.MethodHandles; -import java.lang.invoke.MethodType; -import java.lang.reflect.AccessFlag; import java.lang.runtime.ExactConversionsSupport; -import java.lang.runtime.SwitchBootstraps; -import java.util.concurrent.atomic.AtomicBoolean; - -import static org.testng.Assert.*; +import org.junit.jupiter.api.Test; /** * @test * @bug 8304487 * @summary Verify boundary and special cases of exact conversion predicates * @compile ExactnessConversionsSupportTest.java - * @run testng/othervm ExactnessConversionsSupportTest + * @run junit/othervm ExactnessConversionsSupportTest */ -@Test public class ExactnessConversionsSupportTest { - public static void main(String[] args) { - testByte(); - testShort(); - testChar(); - testInt(); - testLong(); - testFloat(); - testDouble(); - } - - public static void testByte() { + @Test + public void testByte() { assertEquals(true, ExactConversionsSupport.isIntToByteExact((byte) (Byte.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isIntToByteExact((byte) (0))); assertEquals(true, ExactConversionsSupport.isIntToByteExact((byte) (Byte.MIN_VALUE))); @@ -92,7 +66,8 @@ public class ExactnessConversionsSupportTest { assertEquals(false, ExactConversionsSupport.isDoubleToByteExact(-0.0d)); assertEquals(true, ExactConversionsSupport.isDoubleToByteExact(+0.0d)); } - public static void testShort() { + @Test + public void testShort() { assertEquals(true, ExactConversionsSupport.isIntToShortExact((byte) (Byte.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isIntToShortExact((byte) (0))); assertEquals(true, ExactConversionsSupport.isIntToShortExact((byte) (Byte.MIN_VALUE))); @@ -125,7 +100,8 @@ public class ExactnessConversionsSupportTest { assertEquals(false, ExactConversionsSupport.isDoubleToShortExact(-0.0d)); assertEquals(true, ExactConversionsSupport.isDoubleToShortExact(+0.0d)); } - public static void testChar() { + @Test + public void testChar() { assertEquals(true, ExactConversionsSupport.isIntToCharExact((byte) (Byte.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isIntToCharExact((byte) (0))); assertEquals(false, ExactConversionsSupport.isIntToCharExact((byte) (Byte.MIN_VALUE))); @@ -157,7 +133,8 @@ public class ExactnessConversionsSupportTest { assertEquals(false, ExactConversionsSupport.isDoubleToCharExact(-0.0d)); assertEquals(true, ExactConversionsSupport.isDoubleToCharExact(+0.0d)); } - public static void testInt() { + @Test + public void testInt() { assertEquals(false, ExactConversionsSupport.isLongToIntExact((Long.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isLongToIntExact((0L))); assertEquals(false, ExactConversionsSupport.isLongToIntExact((Long.MIN_VALUE))); @@ -178,7 +155,8 @@ public class ExactnessConversionsSupportTest { assertEquals(false, ExactConversionsSupport.isDoubleToIntExact((-0.0d))); assertEquals(true, ExactConversionsSupport.isDoubleToIntExact((+0.0d))); } - public static void testLong() { + @Test + public void testLong() { assertEquals(false, ExactConversionsSupport.isFloatToLongExact((Float.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isFloatToLongExact(((float) 0))); assertEquals(false, ExactConversionsSupport.isFloatToLongExact((Float.MIN_VALUE))); @@ -196,7 +174,8 @@ public class ExactnessConversionsSupportTest { assertEquals(false, ExactConversionsSupport.isDoubleToLongExact((-0.0d))); assertEquals(true, ExactConversionsSupport.isDoubleToLongExact((+0.0d))); } - public static void testFloat() { + @Test + public void testFloat() { assertEquals(true, ExactConversionsSupport.isIntToFloatExact(((byte) (Byte.MAX_VALUE)))); assertEquals(true, ExactConversionsSupport.isIntToFloatExact(((byte) (0)))); assertEquals(true, ExactConversionsSupport.isIntToFloatExact(((byte) (Byte.MIN_VALUE)))); @@ -220,7 +199,8 @@ public class ExactnessConversionsSupportTest { assertEquals(true, ExactConversionsSupport.isDoubleToFloatExact((-0.0d))); assertEquals(true, ExactConversionsSupport.isDoubleToFloatExact((+0.0d))); } - public static void testDouble() { + @Test + public void testDouble() { assertEquals(false, ExactConversionsSupport.isLongToDoubleExact((Long.MAX_VALUE))); assertEquals(true, ExactConversionsSupport.isLongToDoubleExact((0L))); assertEquals(true, ExactConversionsSupport.isLongToDoubleExact((Long.MIN_VALUE))); diff --git a/test/jdk/java/lang/runtime/ObjectMethodsTest.java b/test/jdk/java/lang/runtime/ObjectMethodsTest.java index 62c8b034ed1..951d3b68383 100644 --- a/test/jdk/java/lang/runtime/ObjectMethodsTest.java +++ b/test/jdk/java/lang/runtime/ObjectMethodsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -25,7 +25,7 @@ * @test * @bug 8246774 * @summary Basic tests for ObjectMethods - * @run testng ObjectMethodsTest + * @run junit ObjectMethodsTest */ import java.util.List; @@ -34,14 +34,14 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.runtime.ObjectMethods; -import org.testng.annotations.Test; import static java.lang.invoke.MethodType.methodType; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertThrows; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; -@Test +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; + public class ObjectMethodsTest { public static class C { @@ -80,6 +80,7 @@ public class ObjectMethodsTest { static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); + @Test public void testEqualsC() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "equals", C.EQUALS_DESC, C.class, C.NAME_LIST, C.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); @@ -92,6 +93,7 @@ public class ObjectMethodsTest { assertFalse((boolean)handle.invokeExact(c, new Object())); } + @Test public void testEqualsEmpty() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "equals", Empty.EQUALS_DESC, Empty.class, Empty.NAME_LIST, Empty.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); @@ -102,45 +104,50 @@ public class ObjectMethodsTest { assertFalse((boolean)handle.invokeExact(e, new Object())); } + @Test public void testHashCodeC() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "hashCode", C.HASHCODE_DESC, C.class, "x;y", C.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); C c = new C(6, 7); int hc = (int)handle.invokeExact(c); - assertEquals(hc, hashCombiner(c.x(), c.y())); + assertEquals(hashCombiner(c.x(), c.y()), hc); - assertEquals((int)handle.invokeExact(new C(100, 1)), hashCombiner(100, 1)); - assertEquals((int)handle.invokeExact(new C(0, 0)), hashCombiner(0, 0)); - assertEquals((int)handle.invokeExact(new C(-1, 100)), hashCombiner(-1, 100)); - assertEquals((int)handle.invokeExact(new C(100, 1)), hashCombiner(100, 1)); - assertEquals((int)handle.invokeExact(new C(100, -1)), hashCombiner(100, -1)); + assertEquals(hashCombiner(100, 1), (int)handle.invokeExact(new C(100, 1))); + assertEquals(hashCombiner(0, 0), (int)handle.invokeExact(new C(0, 0))); + assertEquals(hashCombiner(-1, 100), (int)handle.invokeExact(new C(-1, 100))); + assertEquals(hashCombiner(100, 1), (int)handle.invokeExact(new C(100, 1))); + assertEquals(hashCombiner(100, -1), (int)handle.invokeExact(new C(100, -1))); } + @Test public void testHashCodeEmpty() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "hashCode", Empty.HASHCODE_DESC, Empty.class, "", Empty.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); Empty e = new Empty(); - assertEquals((int)handle.invokeExact(e), 0); + assertEquals(0, (int)handle.invokeExact(e)); } + @Test public void testToStringC() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "toString", C.TO_STRING_DESC, C.class, C.NAME_LIST, C.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); - assertEquals((String)handle.invokeExact(new C(8, 9)), "C[x=8, y=9]" ); - assertEquals((String)handle.invokeExact(new C(10, 11)), "C[x=10, y=11]" ); - assertEquals((String)handle.invokeExact(new C(100, -9)), "C[x=100, y=-9]"); - assertEquals((String)handle.invokeExact(new C(0, 0)), "C[x=0, y=0]" ); + assertEquals("C[x=8, y=9]", (String)handle.invokeExact(new C(8, 9)) ); + assertEquals("C[x=10, y=11]", (String)handle.invokeExact(new C(10, 11)) ); + assertEquals("C[x=100, y=-9]", (String)handle.invokeExact(new C(100, -9))); + assertEquals("C[x=0, y=0]", (String)handle.invokeExact(new C(0, 0)) ); } + @Test public void testToStringEmpty() throws Throwable { CallSite cs = (CallSite)ObjectMethods.bootstrap(LOOKUP, "toString", Empty.TO_STRING_DESC, Empty.class, Empty.NAME_LIST, Empty.ACCESSORS); MethodHandle handle = cs.dynamicInvoker(); - assertEquals((String)handle.invokeExact(new Empty()), "Empty[]"); + assertEquals("Empty[]", (String)handle.invokeExact(new Empty())); } Class NPE = NullPointerException.class; Class IAE = IllegalArgumentException.class; + @Test public void exceptions() { assertThrows(IAE, () -> ObjectMethods.bootstrap(LOOKUP, "badName", C.EQUALS_DESC, C.class, C.NAME_LIST, C.ACCESSORS)); assertThrows(IAE, () -> ObjectMethods.bootstrap(LOOKUP, "toString", C.TO_STRING_DESC, C.class, "x;y;z", C.ACCESSORS)); diff --git a/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java b/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java index 3a8608866dc..061ce2ae241 100644 --- a/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java +++ b/test/jdk/java/lang/runtime/SwitchBootstrapsTest.java @@ -35,21 +35,20 @@ import java.lang.runtime.SwitchBootstraps; import java.util.concurrent.atomic.AtomicBoolean; import java.lang.classfile.ClassFile; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * @test * @bug 8318144 * @enablePreview * @compile SwitchBootstrapsTest.java - * @run testng/othervm SwitchBootstrapsTest + * @run junit/othervm SwitchBootstrapsTest */ -@Test public class SwitchBootstrapsTest { public static final MethodHandle BSM_TYPE_SWITCH; @@ -70,14 +69,14 @@ public class SwitchBootstrapsTest { private void testType(Object target, int start, int result, Object... labels) throws Throwable { MethodType switchType = MethodType.methodType(int.class, Object.class, int.class); MethodHandle indy = ((CallSite) BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, labels)).dynamicInvoker(); - assertEquals((int) indy.invoke(target, start), result); + assertEquals(result, (int) indy.invoke(target, start)); assertEquals(-1, (int) indy.invoke(null, start)); } private void testPrimitiveType(Object target, Class targetType, int start, int result, Object... labels) throws Throwable { MethodType switchType = MethodType.methodType(int.class, targetType, int.class); MethodHandle indy = ((CallSite) BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, labels)).dynamicInvoker(); - assertEquals((int) indy.invoke(target, start), result); + assertEquals(result, (int) indy.invoke(target, start)); } private void testEnum(Enum target, int start, int result, Object... labels) throws Throwable { @@ -87,7 +86,7 @@ public class SwitchBootstrapsTest { private void testEnum(Class targetClass, Enum target, int start, int result, Object... labels) throws Throwable { MethodType switchType = MethodType.methodType(int.class, targetClass, int.class); MethodHandle indy = ((CallSite) BSM_ENUM_SWITCH.invoke(MethodHandles.lookup(), "", switchType, labels)).dynamicInvoker(); - assertEquals((int) indy.invoke(target, start), result); + assertEquals(result, (int) indy.invoke(target, start)); assertEquals(-1, (int) indy.invoke(null, start)); } @@ -100,6 +99,7 @@ public class SwitchBootstrapsTest { C; } + @Test public void testTypes() throws Throwable { testType("", 0, 0, String.class, Object.class); testType("", 0, 0, Object.class); @@ -138,6 +138,7 @@ public class SwitchBootstrapsTest { }, 0, 1, 1L); } + @Test public void testPrimitiveTypes() throws Throwable { testPrimitiveType((short) 1, short.class, 0, 1, String.class); testPrimitiveType((byte) 1, byte.class,0, 1, String.class, byte.class); @@ -150,52 +151,32 @@ public class SwitchBootstrapsTest { testPrimitiveType(true, boolean.class,0, 1, String.class, boolean.class); } + @Test public void testEnums() throws Throwable { testEnum(E1.A, 0, 2, "B", "C", "A", E1.class); testEnum(E1.B, 0, 0, "B", "C", "A", E1.class); testEnum(E1.B, 1, 3, "B", "C", "A", E1.class); - try { - testEnum(E1.B, 0, -1, E2.class); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, String.class); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, 10); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, new Object()); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, new Object[] { null }); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, ""); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, (Object[]) null); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, E2.class) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, String.class) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, 10) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, new Object()) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, new Object[] { null }) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, "") + ); + assertThrows(NullPointerException.class, () -> + testEnum(E1.B, 0, -1, (Object[]) null) + ); testEnum(E1.B, 0, 0, "B", "A"); testEnum(E1.A, 0, 1, "B", "A"); testEnum(E1.A, 0, 0, "A", "A", "B"); @@ -208,9 +189,10 @@ public class SwitchBootstrapsTest { //null invocation name: MethodType switchType = MethodType.methodType(int.class, E1.class, int.class); MethodHandle indy = ((CallSite) BSM_ENUM_SWITCH.invoke(MethodHandles.lookup(), null, switchType)).dynamicInvoker(); - assertEquals((int) indy.invoke(E1.A, 0), 0); + assertEquals(0, (int) indy.invoke(E1.A, 0)); } + @Test public void testEnumsWithConstants() throws Throwable { enum E { A {}, @@ -239,18 +221,16 @@ public class SwitchBootstrapsTest { testEnum(E.class, E.C, 2, 2, "A", "B"); } + @Test public void testWrongSwitchTypes() throws Throwable { MethodType[] switchTypes = new MethodType[] { MethodType.methodType(int.class, Object.class), MethodType.methodType(int.class, Object.class, Integer.class) }; for (MethodType switchType : switchTypes) { - try { - BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK, expected - } + assertThrows(IllegalArgumentException.class, () -> + BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType) + ); } MethodType[] enumSwitchTypes = new MethodType[] { MethodType.methodType(int.class, Enum.class), @@ -259,25 +239,21 @@ public class SwitchBootstrapsTest { MethodType.methodType(int.class, Enum.class, Integer.class) }; for (MethodType enumSwitchType : enumSwitchTypes) { - try { - BSM_ENUM_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK, expected - } + assertThrows(IllegalArgumentException.class, () -> + BSM_ENUM_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType) + ); } } + @Test public void testSwitchLabelTypes() throws Throwable { enum E {A} - try { - testType(E.A, 0, -1, E.A); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK, expected - } + assertThrows(IllegalArgumentException.class, () -> + testType(E.A, 0, -1, E.A) + ); } + @Test public void testSwitchQualifiedEnum() throws Throwable { enum E {A, B, C} Object[] labels = new Object[] { @@ -290,41 +266,31 @@ public class SwitchBootstrapsTest { testType(E.C, 0, 2, labels); } + @Test public void testNullLabels() throws Throwable { MethodType switchType = MethodType.methodType(int.class, Object.class, int.class); - try { - BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, (Object[]) null); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } - try { + assertThrows(NullPointerException.class, () -> + BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, (Object[]) null) + ); + assertThrows(IllegalArgumentException.class, () -> BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, - new Object[] {1, null, String.class}); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } + new Object[] {1, null, String.class}) + ); MethodType enumSwitchType = MethodType.methodType(int.class, E1.class, int.class); - try { - BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType, (Object[]) null); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } - try { + assertThrows(NullPointerException.class, () -> + BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType, (Object[]) null) + ); + assertThrows(IllegalArgumentException.class, () -> BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType, - new Object[] {1, null, String.class}); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } + new Object[] {1, null, String.class}) + ); //null invocationName is OK: BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), null, switchType, new Object[] {Object.class}); } private static AtomicBoolean enumInitialized = new AtomicBoolean(); + @Test public void testEnumInitialization1() throws Throwable { enumInitialized.set(false); @@ -340,13 +306,14 @@ public class SwitchBootstrapsTest { CallSite invocation = (CallSite) BSM_ENUM_SWITCH.invoke(MethodHandles.lookup(), "", enumSwitchType, new Object[] {"A"}); assertFalse(enumInitialized.get()); - assertEquals(invocation.dynamicInvoker().invoke(null, 0), -1); + assertEquals(-1, invocation.dynamicInvoker().invoke(null, 0)); assertFalse(enumInitialized.get()); E e = E.A; assertTrue(enumInitialized.get()); - assertEquals(invocation.dynamicInvoker().invoke(e, 0), 0); + assertEquals(0, invocation.dynamicInvoker().invoke(e, 0)); } + @Test public void testEnumInitialization2() throws Throwable { enumInitialized.set(false); @@ -365,60 +332,46 @@ public class SwitchBootstrapsTest { }; CallSite invocation = (CallSite) BSM_TYPE_SWITCH.invoke(MethodHandles.lookup(), "", switchType, labels); assertFalse(enumInitialized.get()); - assertEquals(invocation.dynamicInvoker().invoke(null, 0), -1); + assertEquals(-1, invocation.dynamicInvoker().invoke(null, 0)); assertFalse(enumInitialized.get()); - assertEquals(invocation.dynamicInvoker().invoke("test", 0), 1); + assertEquals(1, invocation.dynamicInvoker().invoke("test", 0)); assertFalse(enumInitialized.get()); E e = E.A; assertTrue(enumInitialized.get()); - assertEquals(invocation.dynamicInvoker().invoke(e, 0), 0); + assertEquals(0, invocation.dynamicInvoker().invoke(e, 0)); } + @Test public void testIncorrectEnumLabels() throws Throwable { - try { - testEnum(E1.B, 0, -1, "B", 1); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } - try { - testEnum(E1.B, 0, -1, "B", null); - fail("Didn't get the expected exception."); - } catch (IllegalArgumentException ex) { - //OK - } + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, "B", 1) + ); + assertThrows(IllegalArgumentException.class, () -> + testEnum(E1.B, 0, -1, "B", null) + ); } + @Test public void testIncorrectEnumStartIndex() throws Throwable { - try { - testEnum(E1.B, -1, -1, "B"); - fail("Didn't get the expected exception."); - } catch (IndexOutOfBoundsException ex) { - //OK - } - try { - testEnum(E1.B, 2, -1, "B"); - fail("Didn't get the expected exception."); - } catch (IndexOutOfBoundsException ex) { - //OK - } + assertThrows(IndexOutOfBoundsException.class, () -> + testEnum(E1.B, -1, -1, "B") + ); //OK + assertThrows(IndexOutOfBoundsException.class, () -> + testEnum(E1.B, 2, -1, "B") + ); } + @Test public void testIncorrectTypeStartIndex() throws Throwable { - try { - testType("", -1, -1, ""); - fail("Didn't get the expected exception."); - } catch (IndexOutOfBoundsException ex) { - //OK - } - try { - testType("", 2, -1, ""); - fail("Didn't get the expected exception."); - } catch (IndexOutOfBoundsException ex) { - //OK - } + assertThrows(IndexOutOfBoundsException.class, () -> + testType("", -1, -1, "") + ); + assertThrows(IndexOutOfBoundsException.class, () -> + testType("", 2, -1, "") + ); } + @Test public void testHiddenClassAsCaseLabel() throws Throwable { MethodHandles.Lookup lookup = MethodHandles.lookup(); byte[] classBytes = createClass(); @@ -448,30 +401,22 @@ public class SwitchBootstrapsTest { }); } + @Test public void testNullLookup() throws Throwable { - try { + assertThrows(NullPointerException.class, () -> { MethodType switchType = MethodType.methodType(int.class, Object.class, int.class); BSM_TYPE_SWITCH.invoke(null, "", switchType, Object.class); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } + }); enum E {} - try { + assertThrows(NullPointerException.class, () -> { MethodType switchType = MethodType.methodType(int.class, E.class, int.class); BSM_ENUM_SWITCH.invoke(null, "", switchType, - new Object[] {}); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } - try { + new Object[] {}); + }); + assertThrows(NullPointerException.class, () -> { MethodType switchType = MethodType.methodType(int.class, E.class, int.class); BSM_ENUM_SWITCH.invoke(null, "", switchType, - new Object[] {"A"}); - fail("Didn't get the expected exception."); - } catch (NullPointerException ex) { - //OK - } + new Object[] {"A"}); + }); } } From 42c0126fb2067b5f792e99af9ad131bab7502c08 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 09:47:52 +0000 Subject: [PATCH 042/105] 8376119: G1: Convert volatiles in G1CMMarkStack to Atomic Reviewed-by: kbarrett, iwalulya --- src/hotspot/share/gc/g1/g1ConcurrentMark.cpp | 16 ++++++++-------- src/hotspot/share/gc/g1/g1ConcurrentMark.hpp | 10 +++++----- .../share/gc/g1/g1ConcurrentMark.inline.hpp | 2 +- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp index 52591f7ce5f..2bbfb5032b3 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp @@ -291,9 +291,9 @@ void G1CMMarkStack::expand() { _chunk_allocator.try_expand(); } -void G1CMMarkStack::add_chunk_to_list(TaskQueueEntryChunk* volatile* list, TaskQueueEntryChunk* elem) { - elem->next = *list; - *list = elem; +void G1CMMarkStack::add_chunk_to_list(Atomic* list, TaskQueueEntryChunk* elem) { + elem->next = list->load_relaxed(); + list->store_relaxed(elem); } void G1CMMarkStack::add_chunk_to_chunk_list(TaskQueueEntryChunk* elem) { @@ -307,10 +307,10 @@ void G1CMMarkStack::add_chunk_to_free_list(TaskQueueEntryChunk* elem) { add_chunk_to_list(&_free_list, elem); } -G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::remove_chunk_from_list(TaskQueueEntryChunk* volatile* list) { - TaskQueueEntryChunk* result = *list; +G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::remove_chunk_from_list(Atomic* list) { + TaskQueueEntryChunk* result = list->load_relaxed(); if (result != nullptr) { - *list = (*list)->next; + list->store_relaxed(list->load_relaxed()->next); } return result; } @@ -364,8 +364,8 @@ bool G1CMMarkStack::par_pop_chunk(G1TaskQueueEntry* ptr_arr) { void G1CMMarkStack::set_empty() { _chunks_in_chunk_list = 0; - _chunk_list = nullptr; - _free_list = nullptr; + _chunk_list.store_relaxed(nullptr); + _free_list.store_relaxed(nullptr); _chunk_allocator.reset(); } diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp index 52a1b133439..836d7793f81 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp @@ -210,17 +210,17 @@ private: ChunkAllocator _chunk_allocator; char _pad0[DEFAULT_PADDING_SIZE]; - TaskQueueEntryChunk* volatile _free_list; // Linked list of free chunks that can be allocated by users. + Atomic _free_list; // Linked list of free chunks that can be allocated by users. char _pad1[DEFAULT_PADDING_SIZE - sizeof(TaskQueueEntryChunk*)]; - TaskQueueEntryChunk* volatile _chunk_list; // List of chunks currently containing data. + Atomic _chunk_list; // List of chunks currently containing data. volatile size_t _chunks_in_chunk_list; char _pad2[DEFAULT_PADDING_SIZE - sizeof(TaskQueueEntryChunk*) - sizeof(size_t)]; // Atomically add the given chunk to the list. - void add_chunk_to_list(TaskQueueEntryChunk* volatile* list, TaskQueueEntryChunk* elem); + void add_chunk_to_list(Atomic* list, TaskQueueEntryChunk* elem); // Atomically remove and return a chunk from the given list. Returns null if the // list is empty. - TaskQueueEntryChunk* remove_chunk_from_list(TaskQueueEntryChunk* volatile* list); + TaskQueueEntryChunk* remove_chunk_from_list(Atomic* list); void add_chunk_to_chunk_list(TaskQueueEntryChunk* elem); void add_chunk_to_free_list(TaskQueueEntryChunk* elem); @@ -252,7 +252,7 @@ private: // Return whether the chunk list is empty. Racy due to unsynchronized access to // _chunk_list. - bool is_empty() const { return _chunk_list == nullptr; } + bool is_empty() const { return _chunk_list.load_relaxed() == nullptr; } size_t capacity() const { return _chunk_allocator.capacity(); } diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.inline.hpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.inline.hpp index fe72c68d4eb..2f4824e4cae 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMark.inline.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.inline.hpp @@ -90,7 +90,7 @@ inline void G1CMMarkStack::iterate(Fn fn) const { size_t num_chunks = 0; - TaskQueueEntryChunk* cur = _chunk_list; + TaskQueueEntryChunk* cur = _chunk_list.load_relaxed(); while (cur != nullptr) { guarantee(num_chunks <= _chunks_in_chunk_list, "Found %zu oop chunks which is more than there should be", num_chunks); From 48d636872f1bd239d12823bf2f9d4aa32384f5e5 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 26 Jan 2026 10:15:57 +0000 Subject: [PATCH 043/105] 8376293: Bad copyright header in g1ConcurrentRefineStats.inline.hpp breaks the build Reviewed-by: mhaessig, chagedorn --- src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp index 5460dc35bba..e1a296c6494 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.inline.hpp @@ -8,7 +8,7 @@ * * 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.inline See the GNU General Public License + * 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). * From 30675faa67d1bbb4acc729a841493bb8311416af Mon Sep 17 00:00:00 2001 From: Quan Anh Mai Date: Mon, 26 Jan 2026 11:18:21 +0000 Subject: [PATCH 044/105] 8375653: C2: CmpUNode::sub is not monotonic Reviewed-by: chagedorn, mchevalier --- src/hotspot/share/opto/subnode.cpp | 131 +++-------- .../compiler/c2/gvn/CmpUNodeValueTests.java | 209 ++++++++++++++++++ .../compiler/ccp/TestCmpUMonotonicity.java | 68 ++++++ 3 files changed, 312 insertions(+), 96 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/c2/gvn/CmpUNodeValueTests.java create mode 100644 test/hotspot/jtreg/compiler/ccp/TestCmpUMonotonicity.java diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp index a10cd2a8d5b..548df58eb35 100644 --- a/src/hotspot/share/opto/subnode.cpp +++ b/src/hotspot/share/opto/subnode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -745,71 +745,40 @@ const Type* CmpINode::Value(PhaseGVN* phase) const { // Simplify a CmpU (compare 2 integers) node, based on local information. // If both inputs are constants, compare them. -const Type *CmpUNode::sub( const Type *t1, const Type *t2 ) const { - assert(!t1->isa_ptr(), "obsolete usage of CmpU"); +const Type* CmpUNode::sub(const Type* t1, const Type* t2) const { + const TypeInt* r0 = t1->is_int(); + const TypeInt* r1 = t2->is_int(); - // comparing two unsigned ints - const TypeInt *r0 = t1->is_int(); // Handy access - const TypeInt *r1 = t2->is_int(); - - // Current installed version - // Compare ranges for non-overlap - juint lo0 = r0->_lo; - juint hi0 = r0->_hi; - juint lo1 = r1->_lo; - juint hi1 = r1->_hi; - - // If either one has both negative and positive values, - // it therefore contains both 0 and -1, and since [0..-1] is the - // full unsigned range, the type must act as an unsigned bottom. - bool bot0 = ((jint)(lo0 ^ hi0) < 0); - bool bot1 = ((jint)(lo1 ^ hi1) < 0); - - if (bot0 || bot1) { - // All unsigned values are LE -1 and GE 0. - if (lo0 == 0 && hi0 == 0) { - return TypeInt::CC_LE; // 0 <= bot - } else if ((jint)lo0 == -1 && (jint)hi0 == -1) { - return TypeInt::CC_GE; // -1 >= bot - } else if (lo1 == 0 && hi1 == 0) { - return TypeInt::CC_GE; // bot >= 0 - } else if ((jint)lo1 == -1 && (jint)hi1 == -1) { - return TypeInt::CC_LE; // bot <= -1 - } - } else { - // We can use ranges of the form [lo..hi] if signs are the same. - assert(lo0 <= hi0 && lo1 <= hi1, "unsigned ranges are valid"); - // results are reversed, '-' > '+' for unsigned compare - if (hi0 < lo1) { - return TypeInt::CC_LT; // smaller - } else if (lo0 > hi1) { - return TypeInt::CC_GT; // greater - } else if (hi0 == lo1 && lo0 == hi1) { - return TypeInt::CC_EQ; // Equal results - } else if (lo0 >= hi1) { - return TypeInt::CC_GE; - } else if (hi0 <= lo1) { - // Check for special case in Hashtable::get. (See below.) - if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && is_index_range_check()) - return TypeInt::CC_LT; - return TypeInt::CC_LE; - } - } // Check for special case in Hashtable::get - the hash index is // mod'ed to the table size so the following range check is useless. // Check for: (X Mod Y) CmpU Y, where the mod result and Y both have // to be positive. // (This is a gross hack, since the sub method never // looks at the structure of the node in any other case.) - if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && is_index_range_check()) + if (r0->_lo >= 0 && r1->_lo >= 0 && is_index_range_check()) { return TypeInt::CC_LT; + } + + if (r0->_uhi < r1->_ulo) { + return TypeInt::CC_LT; + } else if (r0->_ulo > r1->_uhi) { + return TypeInt::CC_GT; + } else if (r0->is_con() && r1->is_con()) { + // Since r0->_ulo == r0->_uhi == r0->get_con(), we only reach here if the constants are equal + assert(r0->get_con() == r1->get_con(), "must reach a previous branch otherwise"); + return TypeInt::CC_EQ; + } else if (r0->_uhi == r1->_ulo) { + return TypeInt::CC_LE; + } else if (r0->_ulo == r1->_uhi) { + return TypeInt::CC_GE; + } const Type* joined = r0->join(r1); if (joined == Type::TOP) { return TypeInt::CC_NE; } - return TypeInt::CC; // else use worst case results + return TypeInt::CC; } const Type* CmpUNode::Value(PhaseGVN* phase) const { @@ -963,51 +932,21 @@ const Type *CmpLNode::sub( const Type *t1, const Type *t2 ) const { // Simplify a CmpUL (compare 2 unsigned longs) node, based on local information. // If both inputs are constants, compare them. const Type* CmpULNode::sub(const Type* t1, const Type* t2) const { - assert(!t1->isa_ptr(), "obsolete usage of CmpUL"); - - // comparing two unsigned longs - const TypeLong* r0 = t1->is_long(); // Handy access + const TypeLong* r0 = t1->is_long(); const TypeLong* r1 = t2->is_long(); - // Current installed version - // Compare ranges for non-overlap - julong lo0 = r0->_lo; - julong hi0 = r0->_hi; - julong lo1 = r1->_lo; - julong hi1 = r1->_hi; - - // If either one has both negative and positive values, - // it therefore contains both 0 and -1, and since [0..-1] is the - // full unsigned range, the type must act as an unsigned bottom. - bool bot0 = ((jlong)(lo0 ^ hi0) < 0); - bool bot1 = ((jlong)(lo1 ^ hi1) < 0); - - if (bot0 || bot1) { - // All unsigned values are LE -1 and GE 0. - if (lo0 == 0 && hi0 == 0) { - return TypeInt::CC_LE; // 0 <= bot - } else if ((jlong)lo0 == -1 && (jlong)hi0 == -1) { - return TypeInt::CC_GE; // -1 >= bot - } else if (lo1 == 0 && hi1 == 0) { - return TypeInt::CC_GE; // bot >= 0 - } else if ((jlong)lo1 == -1 && (jlong)hi1 == -1) { - return TypeInt::CC_LE; // bot <= -1 - } - } else { - // We can use ranges of the form [lo..hi] if signs are the same. - assert(lo0 <= hi0 && lo1 <= hi1, "unsigned ranges are valid"); - // results are reversed, '-' > '+' for unsigned compare - if (hi0 < lo1) { - return TypeInt::CC_LT; // smaller - } else if (lo0 > hi1) { - return TypeInt::CC_GT; // greater - } else if (hi0 == lo1 && lo0 == hi1) { - return TypeInt::CC_EQ; // Equal results - } else if (lo0 >= hi1) { - return TypeInt::CC_GE; - } else if (hi0 <= lo1) { - return TypeInt::CC_LE; - } + if (r0->_uhi < r1->_ulo) { + return TypeInt::CC_LT; + } else if (r0->_ulo > r1->_uhi) { + return TypeInt::CC_GT; + } else if (r0->is_con() && r1->is_con()) { + // Since r0->_ulo == r0->_uhi == r0->get_con(), we only reach here if the constants are equal + assert(r0->get_con() == r1->get_con(), "must reach a previous branch otherwise"); + return TypeInt::CC_EQ; + } else if (r0->_uhi == r1->_ulo) { + return TypeInt::CC_LE; + } else if (r0->_ulo == r1->_uhi) { + return TypeInt::CC_GE; } const Type* joined = r0->join(r1); @@ -1015,7 +954,7 @@ const Type* CmpULNode::sub(const Type* t1, const Type* t2) const { return TypeInt::CC_NE; } - return TypeInt::CC; // else use worst case results + return TypeInt::CC; } //============================================================================= diff --git a/test/hotspot/jtreg/compiler/c2/gvn/CmpUNodeValueTests.java b/test/hotspot/jtreg/compiler/c2/gvn/CmpUNodeValueTests.java new file mode 100644 index 00000000000..cbcbda3422f --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/gvn/CmpUNodeValueTests.java @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2026, 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. + */ +package compiler.c2.gvn; + +import compiler.lib.generators.Generators; +import compiler.lib.ir_framework.*; +import jdk.test.lib.Asserts; + +/* + * @test + * @bug 8375653 + * @summary Test that Value computations of CmpUNode are being performed as expected. + * @library /test/lib / + * @run driver ${test.main.class} + */ +public class CmpUNodeValueTests { + public static void main(String[] args) { + TestFramework.run(); + } + + @DontInline + public static int one() { + return 1; + } + + // Move to a separate method to prevent javac folding the constant comparison + @ForceInline + public static int oneInline() { + return 1; + } + + @Run(test = {"testIntControl", "testIntLT", "testIntLE", "testIntGT", "testIntGE", "testIntEQ", "testIntNE", + "testLongControl", "testLongLT", "testLongLE", "testLongGT", "testLongGE", "testLongEQ", "testLongNE"}) + public void run() { + var stream = Generators.G.longs(); + long x = stream.next(); + long y = stream.next(); + + Asserts.assertEQ(0, testIntControl(false, false)); + Asserts.assertEQ(0, testIntControl(false, true)); + Asserts.assertEQ(0, testIntControl(true, false)); + Asserts.assertEQ(1, testIntControl(true, true)); + Asserts.assertEQ(0, testIntLT((int) x)); + Asserts.assertEQ(0, testIntLE(false, false)); + Asserts.assertEQ(0, testIntLE(false, true)); + Asserts.assertEQ(0, testIntLE(true, false)); + Asserts.assertEQ(0, testIntLE(true, true)); + Asserts.assertEQ(0, testIntGT(false, false)); + Asserts.assertEQ(0, testIntGT(false, true)); + Asserts.assertEQ(0, testIntGT(true, false)); + Asserts.assertEQ(0, testIntGT(true, true)); + Asserts.assertEQ(0, testIntGE((int) x, (int) y)); + Asserts.assertEQ(0, testIntEQ()); + Asserts.assertEQ(0, testIntNE(false, false)); + Asserts.assertEQ(0, testIntNE(false, true)); + Asserts.assertEQ(0, testIntNE(true, false)); + Asserts.assertEQ(0, testIntNE(true, true)); + + Asserts.assertEQ(0, testLongControl(false, false)); + Asserts.assertEQ(0, testLongControl(false, true)); + Asserts.assertEQ(0, testLongControl(true, false)); + Asserts.assertEQ(1, testLongControl(true, true)); + Asserts.assertEQ(0, testLongLT((int) x, false)); + Asserts.assertEQ(0, testLongLT((int) x, true)); + Asserts.assertEQ(0, testLongLE(false, false)); + Asserts.assertEQ(0, testLongLE(false, true)); + Asserts.assertEQ(0, testLongLE(true, false)); + Asserts.assertEQ(0, testLongLE(true, true)); + Asserts.assertEQ(0, testLongGT(false, false)); + Asserts.assertEQ(0, testLongGT(false, true)); + Asserts.assertEQ(0, testLongGT(true, false)); + Asserts.assertEQ(0, testLongGT(true, true)); + Asserts.assertEQ(0, testLongGE((int) x, (int) y)); + Asserts.assertEQ(0, testLongEQ()); + Asserts.assertEQ(0, testLongNE(false, false)); + Asserts.assertEQ(0, testLongNE(false, true)); + Asserts.assertEQ(0, testLongNE(true, false)); + Asserts.assertEQ(0, testLongNE(true, true)); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, counts = {IRNode.CMP_U, "1"}) + int testIntControl(boolean b1, boolean b2) { + int v1 = b1 ? 1 : -1; + int v2 = b2 ? 1 : 0; + return Integer.compareUnsigned(v1, v2) > 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntLT(int x) { + int v1 = x & Integer.MAX_VALUE; // Unset the highest bit, make v1 non-negative + int v2 = Integer.MIN_VALUE; + return Integer.compareUnsigned(v1, v2) < 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntLE(boolean b1, boolean b2) { + int v1 = b1 ? 2 : 0; + int v2 = b2 ? -1 : 2; + return Integer.compareUnsigned(v1, v2) <= 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntGT(boolean b1, boolean b2) { + int v1 = b1 ? Integer.MIN_VALUE : Integer.MAX_VALUE; + int v2 = b2 ? 0 : 2; + return Integer.compareUnsigned(v1, v2) > 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntGE(int x, int y) { + int v1 = x | Integer.MIN_VALUE; // Set the highest bit, make v1 negative + int v2 = y & Integer.MAX_VALUE; // Unset the highest bit, make v2 non-negative + return Integer.compareUnsigned(v1, v2) >= 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntEQ() { + return Integer.compareUnsigned(oneInline(), 1) == 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_U, IRNode.CALL}) + int testIntNE(boolean b1, boolean b2) { + int v1 = b1 ? 1 : -1; + int v2 = b2 ? 0 : 2; + return Integer.compareUnsigned(v1, v2) != 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, counts = {IRNode.CMP_UL, "1"}) + int testLongControl(boolean b1, boolean b2) { + long v1 = b1 ? 1 : -1; + long v2 = b2 ? 1 : 0; + return Long.compareUnsigned(v1, v2) > 0 ? 0 : one(); + } + + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongLT(int x, boolean b2) { + long v1 = Integer.toUnsignedLong(x); + long v2 = Integer.MIN_VALUE; + return Long.compareUnsigned(v1, v2) < 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongLE(boolean b1, boolean b2) { + long v1 = b1 ? 2 : 0; + long v2 = b2 ? -1 : 2; + return Long.compareUnsigned(v1, v2) <= 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongGT(boolean b1, boolean b2) { + long v1 = b1 ? Long.MIN_VALUE : Long.MAX_VALUE; + long v2 = b2 ? 0 : 2; + return Long.compareUnsigned(v1, v2) > 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongGE(int x, int y) { + long v1 = x | Long.MIN_VALUE; // Set the highest bit, make v1 negative + long v2 = y & Long.MAX_VALUE; // Unset the highest bit, make v2 non-negative + return Long.compareUnsigned(v1, v2) >= 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongEQ() { + return Long.compareUnsigned(oneInline(), 1L) == 0 ? 0 : one(); + } + + @Test + @IR(applyIfPlatformOr = {"x64", "true", "aarch64", "true"}, failOn = {IRNode.CMP_UL, IRNode.CALL}) + int testLongNE(boolean b1, boolean b2) { + long v1 = b1 ? 1 : -1; + long v2 = b2 ? 0 : 2; + return Long.compareUnsigned(v1, v2) != 0 ? 0 : one(); + } +} diff --git a/test/hotspot/jtreg/compiler/ccp/TestCmpUMonotonicity.java b/test/hotspot/jtreg/compiler/ccp/TestCmpUMonotonicity.java new file mode 100644 index 00000000000..5ebdd9469fc --- /dev/null +++ b/test/hotspot/jtreg/compiler/ccp/TestCmpUMonotonicity.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2026, 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. + */ +package compiler.ccp; + +/* + * @test + * @bug 8375653 + * @summary Test that CmpUNode::sub conforms monotonicity + * + * @run main ${test.main.class} + * @run main/othervm -Xbatch -XX:CompileCommand=compileonly,${test.main.class}::test* ${test.main.class} + */ +public class TestCmpUMonotonicity { + public static void main(String[] args) { + for (int i = 0; i < 20000; i++) { + testInt(true, 1, 100, 2); + testInt(false, 1, 100, 2); + testLong(true, 1, 100, 2); + testLong(false, 1, 100, 2); + } + } + + private static int testInt(boolean b, int start, int limit, int step) { + int v2 = b ? 1 : -1; + int v1 = 0; + for (int i = start; i < limit; i *= step) { + if (Integer.compareUnsigned(v1, v2) < 0) { + v1 = 2; + } else { + v1 = 0; + } + } + return v1; + } + + private static long testLong(boolean b, int start, int limit, int step) { + long v2 = b ? 1 : -1; + long v1 = 0; + for (int i = start; i < limit; i *= step) { + if (Long.compareUnsigned(v1, v2) < 0) { + v1 = 2; + } else { + v1 = 0; + } + } + return v1; + } +} From 0f1b96a50a3a79fd699bf34121df8451ffa37b8f Mon Sep 17 00:00:00 2001 From: Matthias Baesken Date: Mon, 26 Jan 2026 11:38:05 +0000 Subject: [PATCH 045/105] 8375684: Avoid leak in KeystoreImpl.m when using CFArrayCreateMutable Reviewed-by: clanger --- .../macosx/native/libosxsecurity/KeystoreImpl.m | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/src/java.base/macosx/native/libosxsecurity/KeystoreImpl.m b/src/java.base/macosx/native/libosxsecurity/KeystoreImpl.m index 31572eaeb81..6d8eb832370 100644 --- a/src/java.base/macosx/native/libosxsecurity/KeystoreImpl.m +++ b/src/java.base/macosx/native/libosxsecurity/KeystoreImpl.m @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, 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 @@ -134,10 +134,11 @@ static OSStatus completeCertChain( CFArrayAppendValue(certArray, identity); /* the single element in certs-to-be-evaluated comes from the identity */ - ortn = SecIdentityCopyCertificate(identity, &certRef); - if(ortn) { + ortn = SecIdentityCopyCertificate(identity, &certRef); + if (ortn) { /* should never happen */ cssmPerror("SecIdentityCopyCertificate", ortn); + CFRelease(certArray); return ortn; } @@ -283,6 +284,7 @@ static void addIdentitiesToKeystore(JNIEnv *env, jobject keyStore, jmethodID jm_ OSStatus err = SecIdentitySearchCreate(NULL, 0, &identitySearch); SecIdentityRef theIdentity = NULL; OSErr searchResult = noErr; + CFArrayRef certChain = NULL; do { searchResult = SecIdentitySearchCopyNext(identitySearch, &theIdentity); @@ -291,7 +293,6 @@ static void addIdentitiesToKeystore(JNIEnv *env, jobject keyStore, jmethodID jm_ // Get the cert from the identity, then generate a chain. SecCertificateRef certificate; SecIdentityCopyCertificate(theIdentity, &certificate); - CFArrayRef certChain = NULL; // *** Should do something with this error... err = completeCertChain(theIdentity, NULL, TRUE, &certChain); @@ -357,6 +358,11 @@ static void addIdentitiesToKeystore(JNIEnv *env, jobject keyStore, jmethodID jm_ if ((*env)->ExceptionCheck(env)) { goto errOut; } + + if (certChain != NULL) { + CFRelease(certChain); + certChain = NULL; + } } } while (searchResult == noErr); @@ -364,6 +370,9 @@ errOut: if (identitySearch != NULL) { CFRelease(identitySearch); } + if (certChain != NULL) { + CFRelease(certChain); + } } #define ADD(list, str) { \ From de5c7a9e8607b2a6219d98f9b81ddce4ca92baef Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 12:16:05 +0000 Subject: [PATCH 046/105] 8374676: ZGC: Convert zAbort to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zAbort.cpp | 7 +++---- src/hotspot/share/gc/z/zAbort.hpp | 5 +++-- src/hotspot/share/gc/z/zAbort.inline.hpp | 6 ++---- 3 files changed, 8 insertions(+), 10 deletions(-) diff --git a/src/hotspot/share/gc/z/zAbort.cpp b/src/hotspot/share/gc/z/zAbort.cpp index 3310793f730..82523ddebe8 100644 --- a/src/hotspot/share/gc/z/zAbort.cpp +++ b/src/hotspot/share/gc/z/zAbort.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -22,10 +22,9 @@ */ #include "gc/z/zAbort.hpp" -#include "runtime/atomicAccess.hpp" -volatile bool ZAbort::_should_abort = false; +Atomic ZAbort::_should_abort{}; void ZAbort::abort() { - AtomicAccess::store(&_should_abort, true); + _should_abort.store_relaxed(true); } diff --git a/src/hotspot/share/gc/z/zAbort.hpp b/src/hotspot/share/gc/z/zAbort.hpp index 925b0a79ac3..64633752d5d 100644 --- a/src/hotspot/share/gc/z/zAbort.hpp +++ b/src/hotspot/share/gc/z/zAbort.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -25,10 +25,11 @@ #define SHARE_GC_Z_ZABORT_HPP #include "memory/allStatic.hpp" +#include "runtime/atomic.hpp" class ZAbort : public AllStatic { private: - static volatile bool _should_abort; + static Atomic _should_abort; public: static bool should_abort(); diff --git a/src/hotspot/share/gc/z/zAbort.inline.hpp b/src/hotspot/share/gc/z/zAbort.inline.hpp index 37503e25f70..856179e9d2a 100644 --- a/src/hotspot/share/gc/z/zAbort.inline.hpp +++ b/src/hotspot/share/gc/z/zAbort.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -26,10 +26,8 @@ #include "gc/z/zAbort.hpp" -#include "runtime/atomicAccess.hpp" - inline bool ZAbort::should_abort() { - return AtomicAccess::load(&_should_abort); + return _should_abort.load_relaxed(); } #endif // SHARE_GC_Z_ZABORT_INLINE_HPP From 8a9127fc2d1f8c1cba952744e1a5a7533bb03537 Mon Sep 17 00:00:00 2001 From: Daniel Fuchs Date: Mon, 26 Jan 2026 12:57:23 +0000 Subject: [PATCH 047/105] 8376118: java/net/httpclient/StreamingBody.java fails intermittently on Windows Reviewed-by: vyazici, jpai --- .../java/net/httpclient/StreamingBody.java | 223 +++++++++++++++--- 1 file changed, 190 insertions(+), 33 deletions(-) diff --git a/test/jdk/java/net/httpclient/StreamingBody.java b/test/jdk/java/net/httpclient/StreamingBody.java index c2ad19cf7b7..3fb4f29208e 100644 --- a/test/jdk/java/net/httpclient/StreamingBody.java +++ b/test/jdk/java/net/httpclient/StreamingBody.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, 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 @@ -25,11 +25,12 @@ * @test * @summary Exercise a streaming subscriber ( InputStream ) without holding a * strong (or any ) reference to the client. + * @key randomness * @library /test/lib /test/jdk/java/net/httpclient/lib * @build jdk.httpclient.test.lib.common.HttpServerAdapters jdk.test.lib.net.SimpleSSLContext - * @run testng/othervm + * @run junit/othervm * -Djdk.httpclient.HttpClient.log=trace,headers,requests - * StreamingBody + * ${test.main.class} */ import java.io.IOException; @@ -40,13 +41,15 @@ import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; +import java.util.Random; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; import javax.net.ssl.SSLContext; import jdk.httpclient.test.lib.common.HttpServerAdapters; +import jdk.test.lib.RandomFactory; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.System.out; import static java.net.http.HttpClient.Version.HTTP_1_1; import static java.net.http.HttpClient.Version.HTTP_2; @@ -55,8 +58,21 @@ import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; import static java.nio.charset.StandardCharsets.UTF_8; import static java.net.http.HttpClient.Builder.NO_PROXY; -import static org.testng.Assert.assertEquals; +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class StreamingBody implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); @@ -71,10 +87,105 @@ public class StreamingBody implements HttpServerAdapters { String https2URI; String http3URI; + static final AtomicLong clientCount = new AtomicLong(); + static final AtomicLong serverCount = new AtomicLong(); + static final ConcurrentMap FAILURES = new ConcurrentHashMap<>(); + private static boolean stopAfterFirstFailure() { + return true; + } + + static final long start = System.nanoTime(); + public static String now() { + long now = System.nanoTime() - start; + long secs = now / 1000_000_000; + long mill = (now % 1000_000_000) / 1000_000; + long nan = now % 1000_000; + return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); + } + + final static class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + } + } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } + } + + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + /// The GCTrigger triggers GC at random intervals to + /// help garbage collecting HttpClient intances. This test + /// wants to verify that HttpClient instances which are no + /// longer strongly referenced are not garbage collected + /// before pending HTTP requests are finished. The test + /// creates many client instances (up to 500) and relies + /// on the GC to collect them, since it does not want to + /// keep a strong reference, and therefore cannot not call + /// close(). This can put extra load on the machine since + /// we can't (and don't want to) control when the GC will + /// intervene. The purpose of this class is to trigger the + /// GC at random intervals to 1. help garbage collect client + /// instances earlier, thus reducing the load on the machine, + /// and 2. potentially trigger bugs if the client gets + /// inadvertently GC'ed before the request is finished + /// (which is the bug we're testing for here). + static class GCTrigger { + private final long gcinterval; + private final Thread runner; + private volatile boolean stop; + private final static Random RANDOM = RandomFactory.getRandom(); + + GCTrigger(long gcinterval) { + this.gcinterval = Math.clamp(gcinterval, 100, Long.MAX_VALUE/2); + runner = Thread.ofPlatform().daemon().unstarted(this::loop); + } + + private void loop() { + long min = gcinterval / 2; + long max = gcinterval + min; + while (!stop) { + try { + Thread.sleep(RANDOM.nextLong(min, max)); + } catch (InterruptedException x) { + stop = true; + break; + } + out.println(now() + "triggering gc"); + System.gc(); + } + } + + public void start() { + runner.start(); + } + + public void stop() throws InterruptedException { + stop = true; + runner.interrupt(); + runner.join(); + } + } + + static GCTrigger gcTrigger; static final String MESSAGE = "StreamingBody message body"; static final int ITERATIONS = 100; - @DataProvider(name = "positive") public Object[][] positive() { return new Object[][] { { http3URI, }, @@ -94,72 +205,118 @@ public class StreamingBody implements HttpServerAdapters { return builder; } - @Test(dataProvider = "positive") + @ParameterizedTest + @MethodSource("positive") void test(String uriString) throws Exception { - out.printf("%n---- starting (%s) ----%n", uriString); + out.printf("%n%s---- starting (%s) ----%n", now(), uriString); URI uri = URI.create(uriString); HttpRequest request = newRequestBuilder(uri).build(); for (int i=0; i< ITERATIONS; i++) { - out.println("iteration: " + i); - var builder = uriString.contains("/http3/") - ? newClientBuilderForH3() - : HttpClient.newBuilder(); - HttpResponse response = builder - .sslContext(sslContext) - .proxy(NO_PROXY) - .build() - .sendAsync(request, BodyHandlers.ofInputStream()) - .join(); + try { + out.println(now() + "iteration: " + i); + var builder = uriString.contains("/http3/") + ? newClientBuilderForH3() + : HttpClient.newBuilder(); + clientCount.incrementAndGet(); - String body = new String(response.body().readAllBytes(), UTF_8); - out.println("Got response: " + response); - out.println("Got body Path: " + body); + // we want to relinquish the reference to the HttpClient facade + // as soon as possible. We're using `ofInputStream()` because + // the HttpResponse will be returned almost immediately, before + // the response is read. Similarly we use sendAsync() because + // this will return a CompletableFuture and not wait for the + // request to complete within a method called on the client + // facade. + HttpResponse response = builder + .sslContext(sslContext) + .proxy(NO_PROXY) + .build() + .sendAsync(request, BodyHandlers.ofInputStream()) + .join(); - assertEquals(response.statusCode(), 200); - assertEquals(body, MESSAGE); + String body = new String(response.body().readAllBytes(), UTF_8); + out.println("Got response: " + response); + out.println("Got body Path: " + body); + + assertEquals(200, response.statusCode()); + assertEquals(MESSAGE, body); + } catch (Throwable t) { + String msg = "%stest(%s)[%s] failed: %s" + .formatted(now(), uriString, i, t); + out.println(msg); + throw new AssertionError(msg, t); + } } } // -- Infrastructure - @BeforeTest + @BeforeAll public void setup() throws Exception { httpTestServer = HttpTestServer.create(HTTP_1_1); httpTestServer.addHandler(new MessageHandler(), "/http1/streamingbody/"); httpURI = "http://" + httpTestServer.serverAuthority() + "/http1/streamingbody/w"; + serverCount.incrementAndGet(); httpsTestServer = HttpTestServer.create(HTTP_1_1, sslContext); httpsTestServer.addHandler(new MessageHandler(),"/https1/streamingbody/"); httpsURI = "https://" + httpsTestServer.serverAuthority() + "/https1/streamingbody/x"; + serverCount.incrementAndGet(); http2TestServer = HttpTestServer.create(HTTP_2); http2TestServer.addHandler(new MessageHandler(), "/http2/streamingbody/"); http2URI = "http://" + http2TestServer.serverAuthority() + "/http2/streamingbody/y"; + serverCount.incrementAndGet(); https2TestServer = HttpTestServer.create(HTTP_2, sslContext); https2TestServer.addHandler(new MessageHandler(), "/https2/streamingbody/"); https2URI = "https://" + https2TestServer.serverAuthority() + "/https2/streamingbody/z"; + serverCount.incrementAndGet(); http3TestServer = HttpTestServer.create(HTTP_3_URI_ONLY, sslContext); http3TestServer.addHandler(new MessageHandler(), "/http3/streamingbody/"); http3URI = "https://" + http3TestServer.serverAuthority() + "/http3/streamingbody/z"; + serverCount.incrementAndGet(); + + gcTrigger = new GCTrigger(500); httpTestServer.start(); httpsTestServer.start(); http2TestServer.start(); https2TestServer.start(); http3TestServer.start(); + gcTrigger.start(); } - @AfterTest + @AfterAll public void teardown() throws Exception { - httpTestServer.stop(); - httpsTestServer.stop(); - http2TestServer.stop(); - https2TestServer.stop(); - http3TestServer.stop(); + try { + httpTestServer.stop(); + httpsTestServer.stop(); + http2TestServer.stop(); + https2TestServer.stop(); + http3TestServer.stop(); + gcTrigger.stop(); + } finally { + printFailedTests(); + } + } + + static final void printFailedTests() { + out.println("\n========================="); + try { + out.printf("%n%sCreated %s servers and %s clients%n", + now(), serverCount.get(), clientCount.get()); + if (FAILURES.isEmpty()) return; + out.println("Failed tests: "); + FAILURES.entrySet().forEach((e) -> { + out.printf("\t%s: %s%n", e.getKey(), e.getValue()); + e.getValue().printStackTrace(out); + }); + } finally { + out.println("\n=========================\n"); + } } static class MessageHandler implements HttpTestHandler { From 37cb22826a8f644c699228b8a68852b59933ead5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hannes=20Walln=C3=B6fer?= Date: Mon, 26 Jan 2026 13:28:04 +0000 Subject: [PATCH 048/105] 8373679: Link color accessibility issue in dark theme Reviewed-by: liach, nbenalla --- .../internal/doclets/formats/html/resources/stylesheet.css | 7 +++++++ .../checkStylesheetClasses/CheckStylesheetClasses.java | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/stylesheet.css b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/stylesheet.css index 53b9d8ca6b2..6198df5c2f3 100644 --- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/stylesheet.css +++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/stylesheet.css @@ -163,6 +163,13 @@ \ '); --current-theme-svg: url("moon.svg"); + div.block a[href], div.horizontal-scroll a[href], div.inherited-list h3 a[href], header > div a[href], + .hierarchy a[href], .index a[href], div.caption a[href], .sub-title a[href], .deprecation-comment a[href], + .serialized-class-details a[href] { + text-decoration: underline; + text-decoration-thickness: 0.02em; + text-underline-offset: 0.12em; + } } /* * Styles for individual HTML elements. diff --git a/test/langtools/jdk/javadoc/doclet/checkStylesheetClasses/CheckStylesheetClasses.java b/test/langtools/jdk/javadoc/doclet/checkStylesheetClasses/CheckStylesheetClasses.java index ee1fa538a57..6740bace528 100644 --- a/test/langtools/jdk/javadoc/doclet/checkStylesheetClasses/CheckStylesheetClasses.java +++ b/test/langtools/jdk/javadoc/doclet/checkStylesheetClasses/CheckStylesheetClasses.java @@ -122,7 +122,7 @@ public class CheckStylesheetClasses { "modifiers", "permits", "return-type"); // misc: these are defined in HtmlStyle, and used by the doclet - removeAll(htmlStyleNames, "col-plain", "external-link", "header", "index", + removeAll(htmlStyleNames, "col-plain", "external-link", "header", "package-uses", "packages", "permits-note", "serialized-package-container", "source-container"); From 319e21e9b48b4a9646c803e23d16f0b7df827d3f Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 13:44:06 +0000 Subject: [PATCH 049/105] 8374677: ZGC: Convert zArray to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zArray.hpp | 8 +++++--- src/hotspot/share/gc/z/zArray.inline.hpp | 7 +++---- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/hotspot/share/gc/z/zArray.hpp b/src/hotspot/share/gc/z/zArray.hpp index 2c2f8a5dbfb..d39def4096e 100644 --- a/src/hotspot/share/gc/z/zArray.hpp +++ b/src/hotspot/share/gc/z/zArray.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -26,7 +26,7 @@ #include "cppstdlib/type_traits.hpp" #include "memory/allocation.hpp" -#include "runtime/atomicAccess.hpp" +#include "runtime/atomic.hpp" #include "runtime/os.hpp" #include "runtime/thread.hpp" #include "utilities/growableArray.hpp" @@ -78,7 +78,9 @@ public: template class ZArrayIteratorImpl : public StackObj { private: - size_t _next; + using NextType = std::conditional_t, size_t>; + + NextType _next; const size_t _end; const T* const _array; diff --git a/src/hotspot/share/gc/z/zArray.inline.hpp b/src/hotspot/share/gc/z/zArray.inline.hpp index 9e2bc19118e..15caa54ebab 100644 --- a/src/hotspot/share/gc/z/zArray.inline.hpp +++ b/src/hotspot/share/gc/z/zArray.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -27,7 +27,6 @@ #include "gc/z/zArray.hpp" #include "gc/z/zLock.inline.hpp" -#include "runtime/atomicAccess.hpp" template ZArraySlice::ZArraySlice(T* data, int len) @@ -130,7 +129,7 @@ inline bool ZArrayIteratorImpl::next_serial(size_t* index) { template inline bool ZArrayIteratorImpl::next_parallel(size_t* index) { - const size_t claimed_index = AtomicAccess::fetch_then_add(&_next, 1u, memory_order_relaxed); + const size_t claimed_index = _next.fetch_then_add(1u, memory_order_relaxed); if (claimed_index < _end) { *index = claimed_index; @@ -177,7 +176,7 @@ inline bool ZArrayIteratorImpl::next_if(T* elem, Function predicate template inline bool ZArrayIteratorImpl::next_index(size_t* index) { - if (Parallel) { + if constexpr (Parallel) { return next_parallel(index); } else { return next_serial(index); From 512f95cf2632167149e2118853ab4d6d636fe0a3 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 13:53:12 +0000 Subject: [PATCH 050/105] 8374678: ZGC: Convert zForwarding to use Atomic Reviewed-by: stefank, eosterlund --- src/hotspot/share/gc/z/vmStructs_z.hpp | 3 +- src/hotspot/share/gc/z/zForwarding.cpp | 45 +++++++++---------- src/hotspot/share/gc/z/zForwarding.hpp | 13 +++--- src/hotspot/share/gc/z/zForwarding.inline.hpp | 14 +++--- 4 files changed, 37 insertions(+), 38 deletions(-) diff --git a/src/hotspot/share/gc/z/vmStructs_z.hpp b/src/hotspot/share/gc/z/vmStructs_z.hpp index a88dae188d3..de32b964a51 100644 --- a/src/hotspot/share/gc/z/vmStructs_z.hpp +++ b/src/hotspot/share/gc/z/vmStructs_z.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -111,7 +111,6 @@ typedef ZValue ZPerNUMAZPartition; \ nonstatic_field(ZForwarding, _virtual, const ZVirtualMemory) \ nonstatic_field(ZForwarding, _object_alignment_shift, const size_t) \ - volatile_nonstatic_field(ZForwarding, _ref_count, int) \ nonstatic_field(ZForwarding, _entries, const ZAttachedArrayForForwarding) \ nonstatic_field(ZForwardingEntry, _entry, uint64_t) \ nonstatic_field(ZAttachedArrayForForwarding, _length, const size_t) diff --git a/src/hotspot/share/gc/z/zForwarding.cpp b/src/hotspot/share/gc/z/zForwarding.cpp index 820bb9dbc35..92fc1bc89df 100644 --- a/src/hotspot/share/gc/z/zForwarding.cpp +++ b/src/hotspot/share/gc/z/zForwarding.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -29,7 +29,6 @@ #include "gc/z/zStat.hpp" #include "gc/z/zUtils.inline.hpp" #include "logging/log.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/align.hpp" // @@ -50,7 +49,7 @@ // bool ZForwarding::claim() { - return AtomicAccess::cmpxchg(&_claimed, false, true) == false; + return _claimed.compare_set(false, true); } void ZForwarding::in_place_relocation_start(zoffset relocated_watermark) { @@ -60,7 +59,7 @@ void ZForwarding::in_place_relocation_start(zoffset relocated_watermark) { // Support for ZHeap::is_in checks of from-space objects // in a page that is in-place relocating - AtomicAccess::store(&_in_place_thread, Thread::current()); + _in_place_thread.store_relaxed(Thread::current()); _in_place_top_at_start = _page->top(); } @@ -76,17 +75,17 @@ void ZForwarding::in_place_relocation_finish() { } // Disable relaxed ZHeap::is_in checks - AtomicAccess::store(&_in_place_thread, (Thread*)nullptr); + _in_place_thread.store_relaxed(nullptr); } bool ZForwarding::in_place_relocation_is_below_top_at_start(zoffset offset) const { // Only the relocating thread is allowed to know about the old relocation top. - return AtomicAccess::load(&_in_place_thread) == Thread::current() && offset < _in_place_top_at_start; + return _in_place_thread.load_relaxed() == Thread::current() && offset < _in_place_top_at_start; } bool ZForwarding::retain_page(ZRelocateQueue* queue) { for (;;) { - const int32_t ref_count = AtomicAccess::load_acquire(&_ref_count); + const int32_t ref_count = _ref_count.load_acquire(); if (ref_count == 0) { // Released @@ -101,7 +100,7 @@ bool ZForwarding::retain_page(ZRelocateQueue* queue) { return false; } - if (AtomicAccess::cmpxchg(&_ref_count, ref_count, ref_count + 1) == ref_count) { + if (_ref_count.compare_set(ref_count, ref_count + 1)) { // Retained return true; } @@ -110,11 +109,11 @@ bool ZForwarding::retain_page(ZRelocateQueue* queue) { void ZForwarding::in_place_relocation_claim_page() { for (;;) { - const int32_t ref_count = AtomicAccess::load(&_ref_count); + const int32_t ref_count = _ref_count.load_relaxed(); assert(ref_count > 0, "Invalid state"); // Invert reference count - if (AtomicAccess::cmpxchg(&_ref_count, ref_count, -ref_count) != ref_count) { + if (!_ref_count.compare_set(ref_count, -ref_count)) { continue; } @@ -122,7 +121,7 @@ void ZForwarding::in_place_relocation_claim_page() { // and we have now claimed the page. Otherwise we wait until it is claimed. if (ref_count != 1) { ZLocker locker(&_ref_lock); - while (AtomicAccess::load_acquire(&_ref_count) != -1) { + while (_ref_count.load_acquire() != -1) { _ref_lock.wait(); } } @@ -134,12 +133,12 @@ void ZForwarding::in_place_relocation_claim_page() { void ZForwarding::release_page() { for (;;) { - const int32_t ref_count = AtomicAccess::load(&_ref_count); + const int32_t ref_count = _ref_count.load_relaxed(); assert(ref_count != 0, "Invalid state"); if (ref_count > 0) { // Decrement reference count - if (AtomicAccess::cmpxchg(&_ref_count, ref_count, ref_count - 1) != ref_count) { + if (!_ref_count.compare_set(ref_count, ref_count - 1)) { continue; } @@ -152,7 +151,7 @@ void ZForwarding::release_page() { } } else { // Increment reference count - if (AtomicAccess::cmpxchg(&_ref_count, ref_count, ref_count + 1) != ref_count) { + if (!_ref_count.compare_set(ref_count, ref_count + 1)) { continue; } @@ -171,9 +170,9 @@ void ZForwarding::release_page() { ZPage* ZForwarding::detach_page() { // Wait until released - if (AtomicAccess::load_acquire(&_ref_count) != 0) { + if (_ref_count.load_acquire() != 0) { ZLocker locker(&_ref_lock); - while (AtomicAccess::load_acquire(&_ref_count) != 0) { + while (_ref_count.load_acquire() != 0) { _ref_lock.wait(); } } @@ -182,16 +181,16 @@ ZPage* ZForwarding::detach_page() { } ZPage* ZForwarding::page() { - assert(AtomicAccess::load(&_ref_count) != 0, "The page has been released/detached"); + assert(_ref_count.load_relaxed() != 0, "The page has been released/detached"); return _page; } void ZForwarding::mark_done() { - AtomicAccess::store(&_done, true); + _done.store_relaxed(true); } bool ZForwarding::is_done() const { - return AtomicAccess::load(&_done); + return _done.load_relaxed(); } // @@ -288,7 +287,7 @@ void ZForwarding::relocated_remembered_fields_publish() { // used to have remembered set entries. Now publish the fields to // the YC. - const ZPublishState res = AtomicAccess::cmpxchg(&_relocated_remembered_fields_state, ZPublishState::none, ZPublishState::published); + const ZPublishState res = _relocated_remembered_fields_state.compare_exchange(ZPublishState::none, ZPublishState::published); // none: OK to publish // published: Not possible - this operation makes this transition @@ -319,7 +318,7 @@ void ZForwarding::relocated_remembered_fields_notify_concurrent_scan_of() { // Invariant: The page is being retained assert(ZGeneration::young()->is_phase_mark(), "Only called when"); - const ZPublishState res = AtomicAccess::cmpxchg(&_relocated_remembered_fields_state, ZPublishState::none, ZPublishState::reject); + const ZPublishState res = _relocated_remembered_fields_state.compare_exchange(ZPublishState::none, ZPublishState::reject); // none: OC has not completed relocation // published: OC has completed and published all relocated remembered fields @@ -340,7 +339,7 @@ void ZForwarding::relocated_remembered_fields_notify_concurrent_scan_of() { // OC relocation already collected and published fields // Still notify concurrent scanning and reject the collected data from the OC - const ZPublishState res2 = AtomicAccess::cmpxchg(&_relocated_remembered_fields_state, ZPublishState::published, ZPublishState::reject); + const ZPublishState res2 = _relocated_remembered_fields_state.compare_exchange(ZPublishState::published, ZPublishState::reject); assert(res2 == ZPublishState::published, "Should not fail"); log_debug(gc, remset)("Forwarding remset eager and reject: " PTR_FORMAT " " PTR_FORMAT, untype(start()), untype(end())); @@ -368,7 +367,7 @@ bool ZForwarding::relocated_remembered_fields_published_contains(volatile zpoint } void ZForwarding::verify() const { - guarantee(_ref_count != 0, "Invalid reference count"); + guarantee(_ref_count.load_relaxed() != 0, "Invalid reference count"); guarantee(_page != nullptr, "Invalid page"); uint32_t live_objects = 0; diff --git a/src/hotspot/share/gc/z/zForwarding.hpp b/src/hotspot/share/gc/z/zForwarding.hpp index 29b5cf4aabe..72319bd2ebb 100644 --- a/src/hotspot/share/gc/z/zForwarding.hpp +++ b/src/hotspot/share/gc/z/zForwarding.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -32,6 +32,7 @@ #include "gc/z/zPageAge.hpp" #include "gc/z/zPageType.hpp" #include "gc/z/zVirtualMemory.hpp" +#include "runtime/atomic.hpp" class ObjectClosure; class ZForwardingAllocator; @@ -62,13 +63,13 @@ private: const uint32_t _partition_id; const ZPageAge _from_age; const ZPageAge _to_age; - volatile bool _claimed; + Atomic _claimed; mutable ZConditionLock _ref_lock; - volatile int32_t _ref_count; - volatile bool _done; + Atomic _ref_count; + Atomic _done; // Relocated remembered set fields support - volatile ZPublishState _relocated_remembered_fields_state; + Atomic _relocated_remembered_fields_state; PointerArray _relocated_remembered_fields_array; uint32_t _relocated_remembered_fields_publish_young_seqnum; @@ -77,7 +78,7 @@ private: zoffset_end _in_place_top_at_start; // Debugging - volatile Thread* _in_place_thread; + Atomic _in_place_thread; ZForwardingEntry* entries() const; ZForwardingEntry at(ZForwardingCursor* cursor) const; diff --git a/src/hotspot/share/gc/z/zForwarding.inline.hpp b/src/hotspot/share/gc/z/zForwarding.inline.hpp index 45b5d495e79..02f61eb5b05 100644 --- a/src/hotspot/share/gc/z/zForwarding.inline.hpp +++ b/src/hotspot/share/gc/z/zForwarding.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -196,7 +196,7 @@ void ZForwarding::oops_do_in_forwarded_via_table(Function function) { } inline bool ZForwarding::in_place_relocation() const { - assert(AtomicAccess::load(&_ref_count) != 0, "The page has been released/detached"); + assert(_ref_count.load_relaxed() != 0, "The page has been released/detached"); return _in_place; } @@ -307,7 +307,7 @@ inline void ZForwarding::relocated_remembered_fields_register(volatile zpointer* // Invariant: Page is being retained assert(ZGeneration::young()->is_phase_mark(), "Only called when"); - const ZPublishState res = AtomicAccess::load(&_relocated_remembered_fields_state); + const ZPublishState res = _relocated_remembered_fields_state.load_relaxed(); // none: Gather remembered fields // published: Have already published fields - not possible since they haven't been @@ -327,7 +327,7 @@ inline void ZForwarding::relocated_remembered_fields_register(volatile zpointer* // Returns true iff the page is being (or about to be) relocated by the OC // while the YC gathered the remembered fields of the "from" page. inline bool ZForwarding::relocated_remembered_fields_is_concurrently_scanned() const { - return AtomicAccess::load(&_relocated_remembered_fields_state) == ZPublishState::reject; + return _relocated_remembered_fields_state.load_relaxed() == ZPublishState::reject; } template @@ -335,7 +335,7 @@ inline void ZForwarding::relocated_remembered_fields_apply_to_published(Function // Invariant: Page is not being retained assert(ZGeneration::young()->is_phase_mark(), "Only called when"); - const ZPublishState res = AtomicAccess::load_acquire(&_relocated_remembered_fields_state); + const ZPublishState res = _relocated_remembered_fields_state.load_acquire(); // none: Nothing published - page had already been relocated before YC started // published: OC relocated and published relocated remembered fields @@ -363,14 +363,14 @@ inline void ZForwarding::relocated_remembered_fields_apply_to_published(Function // collection. Mark that it is unsafe (and unnecessary) to call scan_page // on the page in the page table. assert(res != ZPublishState::accept, "Unexpected"); - AtomicAccess::store(&_relocated_remembered_fields_state, ZPublishState::reject); + _relocated_remembered_fields_state.store_relaxed(ZPublishState::reject); } else { log_debug(gc, remset)("scan_forwarding failed retain safe " PTR_FORMAT, untype(start())); // Guaranteed that the page was fully relocated and removed from page table. // Because of this we can signal to scan_page that any page found in page table // of the same slot as the current forwarding is a page that is safe to scan, // and in fact must be scanned. - AtomicAccess::store(&_relocated_remembered_fields_state, ZPublishState::accept); + _relocated_remembered_fields_state.store_relaxed(ZPublishState::accept); } } From fef85ff932055cd5385633f3b283e6201cdcaa68 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 14:13:48 +0000 Subject: [PATCH 051/105] 8374679: ZGC: Convert zForwardingAllocator to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zForwardingAllocator.cpp | 5 +++-- src/hotspot/share/gc/z/zForwardingAllocator.hpp | 9 +++++---- src/hotspot/share/gc/z/zForwardingAllocator.inline.hpp | 7 +++---- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/src/hotspot/share/gc/z/zForwardingAllocator.cpp b/src/hotspot/share/gc/z/zForwardingAllocator.cpp index 0b4e6c7b08c..451a1d62754 100644 --- a/src/hotspot/share/gc/z/zForwardingAllocator.cpp +++ b/src/hotspot/share/gc/z/zForwardingAllocator.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -34,6 +34,7 @@ ZForwardingAllocator::~ZForwardingAllocator() { } void ZForwardingAllocator::reset(size_t size) { - _start = _top = REALLOC_C_HEAP_ARRAY(char, _start, size, mtGC); + _start = REALLOC_C_HEAP_ARRAY(char, _start, size, mtGC); + _top.store_relaxed(_start); _end = _start + size; } diff --git a/src/hotspot/share/gc/z/zForwardingAllocator.hpp b/src/hotspot/share/gc/z/zForwardingAllocator.hpp index 8424fe6cd70..62d84885692 100644 --- a/src/hotspot/share/gc/z/zForwardingAllocator.hpp +++ b/src/hotspot/share/gc/z/zForwardingAllocator.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -24,13 +24,14 @@ #ifndef SHARE_GC_Z_ZFORWARDINGALLOCATOR_HPP #define SHARE_GC_Z_ZFORWARDINGALLOCATOR_HPP +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" class ZForwardingAllocator { private: - char* _start; - char* _end; - char* _top; + char* _start; + char* _end; + Atomic _top; public: ZForwardingAllocator(); diff --git a/src/hotspot/share/gc/z/zForwardingAllocator.inline.hpp b/src/hotspot/share/gc/z/zForwardingAllocator.inline.hpp index dc71507175c..c8811c84ede 100644 --- a/src/hotspot/share/gc/z/zForwardingAllocator.inline.hpp +++ b/src/hotspot/share/gc/z/zForwardingAllocator.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -26,7 +26,6 @@ #include "gc/z/zForwardingAllocator.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/debug.hpp" inline size_t ZForwardingAllocator::size() const { @@ -34,11 +33,11 @@ inline size_t ZForwardingAllocator::size() const { } inline bool ZForwardingAllocator::is_full() const { - return _top == _end; + return _top.load_relaxed() == _end; } inline void* ZForwardingAllocator::alloc(size_t size) { - char* const addr = AtomicAccess::fetch_then_add(&_top, size); + char* const addr = _top.fetch_then_add(size); assert(addr + size <= _end, "Allocation should never fail"); return addr; } From b59f49a1c3e370f794291a1f948e67d2651ece11 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 14:28:39 +0000 Subject: [PATCH 052/105] 8374680: ZGC: Convert zGeneration to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zGeneration.cpp | 21 ++++++++++----------- src/hotspot/share/gc/z/zGeneration.hpp | 9 +++++---- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/hotspot/share/gc/z/zGeneration.cpp b/src/hotspot/share/gc/z/zGeneration.cpp index a8c646bf895..27f352a624f 100644 --- a/src/hotspot/share/gc/z/zGeneration.cpp +++ b/src/hotspot/share/gc/z/zGeneration.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -56,7 +56,6 @@ #include "logging/log.hpp" #include "memory/universe.hpp" #include "prims/jvmtiTagMap.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/continuation.hpp" #include "runtime/handshake.hpp" #include "runtime/safepoint.hpp" @@ -298,33 +297,33 @@ bool ZGeneration::is_relocate_queue_active() const { void ZGeneration::reset_statistics() { assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint"); - _freed = 0; - _promoted = 0; - _compacted = 0; + _freed.store_relaxed(0u); + _promoted.store_relaxed(0u); + _compacted.store_relaxed(0u); } size_t ZGeneration::freed() const { - return _freed; + return _freed.load_relaxed(); } void ZGeneration::increase_freed(size_t size) { - AtomicAccess::add(&_freed, size, memory_order_relaxed); + _freed.add_then_fetch(size, memory_order_relaxed); } size_t ZGeneration::promoted() const { - return _promoted; + return _promoted.load_relaxed();; } void ZGeneration::increase_promoted(size_t size) { - AtomicAccess::add(&_promoted, size, memory_order_relaxed); + _promoted.add_then_fetch(size, memory_order_relaxed); } size_t ZGeneration::compacted() const { - return _compacted; + return _compacted.load_relaxed();; } void ZGeneration::increase_compacted(size_t size) { - AtomicAccess::add(&_compacted, size, memory_order_relaxed); + _compacted.add_then_fetch(size, memory_order_relaxed); } ConcurrentGCTimer* ZGeneration::gc_timer() const { diff --git a/src/hotspot/share/gc/z/zGeneration.hpp b/src/hotspot/share/gc/z/zGeneration.hpp index 3b700361460..1371865958b 100644 --- a/src/hotspot/share/gc/z/zGeneration.hpp +++ b/src/hotspot/share/gc/z/zGeneration.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -37,6 +37,7 @@ #include "gc/z/zWeakRootsProcessor.hpp" #include "gc/z/zWorkers.hpp" #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" class ThreadClosure; class ZForwardingTable; @@ -70,9 +71,9 @@ protected: ZRelocate _relocate; ZRelocationSet _relocation_set; - volatile size_t _freed; - volatile size_t _promoted; - volatile size_t _compacted; + Atomic _freed; + Atomic _promoted; + Atomic _compacted; Phase _phase; uint32_t _seqnum; From 61b722d59a799ba943476a03be3a1c7649aa0c27 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 14:45:24 +0000 Subject: [PATCH 053/105] 8374681: ZGC: Convert zJNICritical to use Atomic Reviewed-by: tschatzl, stefank --- src/hotspot/share/gc/z/zJNICritical.cpp | 33 ++++++++++++------------- src/hotspot/share/gc/z/zJNICritical.hpp | 7 +++--- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/hotspot/share/gc/z/zJNICritical.cpp b/src/hotspot/share/gc/z/zJNICritical.cpp index 28cc70cb3b5..f50cc113936 100644 --- a/src/hotspot/share/gc/z/zJNICritical.cpp +++ b/src/hotspot/share/gc/z/zJNICritical.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -24,7 +24,6 @@ #include "gc/z/zJNICritical.hpp" #include "gc/z/zLock.inline.hpp" #include "gc/z/zStat.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/interfaceSupport.inline.hpp" #include "runtime/thread.inline.hpp" #include "utilities/debug.hpp" @@ -46,22 +45,22 @@ static const ZStatCriticalPhase ZCriticalPhaseJNICriticalStall("JNI Critical Stall", false /* verbose */); -volatile int64_t ZJNICritical::_count; -ZConditionLock* ZJNICritical::_lock; +Atomic ZJNICritical::_count; +ZConditionLock* ZJNICritical::_lock; void ZJNICritical::initialize() { - _count = 0; + precond(_count.load_relaxed() == 0); _lock = new ZConditionLock(); } void ZJNICritical::block() { for (;;) { - const int64_t count = AtomicAccess::load_acquire(&_count); + const int64_t count = _count.load_acquire(); if (count < 0) { // Already blocked, wait until unblocked ZLocker locker(_lock); - while (AtomicAccess::load_acquire(&_count) < 0) { + while (_count.load_acquire() < 0) { _lock->wait(); } @@ -70,7 +69,7 @@ void ZJNICritical::block() { } // Increment and invert count - if (AtomicAccess::cmpxchg(&_count, count, -(count + 1)) != count) { + if (!_count.compare_set(count, -(count + 1))) { continue; } @@ -80,7 +79,7 @@ void ZJNICritical::block() { if (count != 0) { // Wait until blocked ZLocker locker(_lock); - while (AtomicAccess::load_acquire(&_count) != -1) { + while (_count.load_acquire() != -1) { _lock->wait(); } } @@ -91,18 +90,18 @@ void ZJNICritical::block() { } void ZJNICritical::unblock() { - const int64_t count = AtomicAccess::load_acquire(&_count); + const int64_t count = _count.load_acquire(); assert(count == -1, "Invalid count"); // Notify unblocked ZLocker locker(_lock); - AtomicAccess::release_store(&_count, (int64_t)0); + _count.release_store(0); _lock->notify_all(); } void ZJNICritical::enter_inner(JavaThread* thread) { for (;;) { - const int64_t count = AtomicAccess::load_acquire(&_count); + const int64_t count = _count.load_acquire(); if (count < 0) { // Wait until unblocked @@ -112,7 +111,7 @@ void ZJNICritical::enter_inner(JavaThread* thread) { ThreadBlockInVM tbivm(thread); ZLocker locker(_lock); - while (AtomicAccess::load_acquire(&_count) < 0) { + while (_count.load_acquire() < 0) { _lock->wait(); } @@ -121,7 +120,7 @@ void ZJNICritical::enter_inner(JavaThread* thread) { } // Increment count - if (AtomicAccess::cmpxchg(&_count, count, count + 1) != count) { + if (!_count.compare_set(count, count + 1)) { continue; } @@ -142,17 +141,17 @@ void ZJNICritical::enter(JavaThread* thread) { void ZJNICritical::exit_inner() { for (;;) { - const int64_t count = AtomicAccess::load_acquire(&_count); + const int64_t count = _count.load_acquire(); assert(count != 0, "Invalid count"); if (count > 0) { // No block in progress, decrement count - if (AtomicAccess::cmpxchg(&_count, count, count - 1) != count) { + if (!_count.compare_set(count, count - 1)) { continue; } } else { // Block in progress, increment count - if (AtomicAccess::cmpxchg(&_count, count, count + 1) != count) { + if (!_count.compare_set(count, count + 1)) { continue; } diff --git a/src/hotspot/share/gc/z/zJNICritical.hpp b/src/hotspot/share/gc/z/zJNICritical.hpp index d2ba80eddba..def6001ae9f 100644 --- a/src/hotspot/share/gc/z/zJNICritical.hpp +++ b/src/hotspot/share/gc/z/zJNICritical.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -25,14 +25,15 @@ #define SHARE_GC_Z_ZJNICRITICAL_HPP #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" class JavaThread; class ZConditionLock; class ZJNICritical : public AllStatic { private: - static volatile int64_t _count; - static ZConditionLock* _lock; + static Atomic _count; + static ZConditionLock* _lock; static void enter_inner(JavaThread* thread); static void exit_inner(); From 99b4e05d502b68844699faa025e0d5bd51135d8f Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 15:05:24 +0000 Subject: [PATCH 054/105] 8374682: ZGC: Convert zLiveMap to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zLiveMap.cpp | 17 ++++++++--------- src/hotspot/share/gc/z/zLiveMap.hpp | 9 +++++---- src/hotspot/share/gc/z/zLiveMap.inline.hpp | 15 +++++++-------- 3 files changed, 20 insertions(+), 21 deletions(-) diff --git a/src/hotspot/share/gc/z/zLiveMap.cpp b/src/hotspot/share/gc/z/zLiveMap.cpp index c4ae41b0873..8b03a97e03f 100644 --- a/src/hotspot/share/gc/z/zLiveMap.cpp +++ b/src/hotspot/share/gc/z/zLiveMap.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -27,7 +27,6 @@ #include "gc/z/zStat.hpp" #include "gc/z/zUtils.hpp" #include "logging/log.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/debug.hpp" #include "utilities/powerOfTwo.hpp" #include "utilities/spinYield.hpp" @@ -60,18 +59,18 @@ void ZLiveMap::reset(ZGenerationId id) { // Multiple threads can enter here, make sure only one of them // resets the marking information while the others busy wait. - for (uint32_t seqnum = AtomicAccess::load_acquire(&_seqnum); + for (uint32_t seqnum = _seqnum.load_acquire(); seqnum != generation->seqnum(); - seqnum = AtomicAccess::load_acquire(&_seqnum)) { + seqnum = _seqnum.load_acquire()) { if (seqnum != seqnum_initializing) { // No one has claimed initialization of the livemap yet - if (AtomicAccess::cmpxchg(&_seqnum, seqnum, seqnum_initializing) == seqnum) { + if (_seqnum.compare_set(seqnum, seqnum_initializing)) { // This thread claimed the initialization // Reset marking information - _live_bytes = 0; - _live_objects = 0; + _live_bytes.store_relaxed(0u); + _live_objects.store_relaxed(0u); // Clear segment claimed/live bits segment_live_bits().clear(); @@ -81,13 +80,13 @@ void ZLiveMap::reset(ZGenerationId id) { // a bit is about to be set for the first time. initialize_bitmap(); - assert(_seqnum == seqnum_initializing, "Invalid"); + assert(_seqnum.load_relaxed() == seqnum_initializing, "Invalid"); // Make sure the newly reset marking information is ordered // before the update of the page seqnum, such that when the // up-to-date seqnum is load acquired, the bit maps will not // contain stale information. - AtomicAccess::release_store(&_seqnum, generation->seqnum()); + _seqnum.release_store(generation->seqnum()); break; } } diff --git a/src/hotspot/share/gc/z/zLiveMap.hpp b/src/hotspot/share/gc/z/zLiveMap.hpp index 71457d05a41..9373f6aad98 100644 --- a/src/hotspot/share/gc/z/zLiveMap.hpp +++ b/src/hotspot/share/gc/z/zLiveMap.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -28,6 +28,7 @@ #include "gc/z/zBitMap.hpp" #include "gc/z/zGenerationId.hpp" #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" class ObjectClosure; @@ -41,9 +42,9 @@ private: const uint32_t _segment_size; const int _segment_shift; - volatile uint32_t _seqnum; - volatile uint32_t _live_objects; - volatile size_t _live_bytes; + Atomic _seqnum; + Atomic _live_objects; + Atomic _live_bytes; BitMap::bm_word_t _segment_live_bits; BitMap::bm_word_t _segment_claim_bits; ZBitMap _bitmap; diff --git a/src/hotspot/share/gc/z/zLiveMap.inline.hpp b/src/hotspot/share/gc/z/zLiveMap.inline.hpp index e6176b928ff..69687d0b595 100644 --- a/src/hotspot/share/gc/z/zLiveMap.inline.hpp +++ b/src/hotspot/share/gc/z/zLiveMap.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -31,24 +31,23 @@ #include "gc/z/zGeneration.inline.hpp" #include "gc/z/zMark.hpp" #include "gc/z/zUtils.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/bitMap.inline.hpp" #include "utilities/debug.hpp" inline void ZLiveMap::reset() { - _seqnum = 0; + _seqnum.store_relaxed(0u); } inline bool ZLiveMap::is_marked(ZGenerationId id) const { - return AtomicAccess::load_acquire(&_seqnum) == ZGeneration::generation(id)->seqnum(); + return _seqnum.load_acquire() == ZGeneration::generation(id)->seqnum(); } inline uint32_t ZLiveMap::live_objects() const { - return _live_objects; + return _live_objects.load_relaxed(); } inline size_t ZLiveMap::live_bytes() const { - return _live_bytes; + return _live_bytes.load_relaxed(); } inline const BitMapView ZLiveMap::segment_live_bits() const { @@ -116,8 +115,8 @@ inline bool ZLiveMap::set(ZGenerationId id, BitMap::idx_t index, bool finalizabl } inline void ZLiveMap::inc_live(uint32_t objects, size_t bytes) { - AtomicAccess::add(&_live_objects, objects); - AtomicAccess::add(&_live_bytes, bytes); + _live_objects.add_then_fetch(objects); + _live_bytes.add_then_fetch(bytes); } inline BitMap::idx_t ZLiveMap::segment_start(BitMap::idx_t segment) const { From 664856757405e149bb98474872938e3a62b62302 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 15:14:42 +0000 Subject: [PATCH 055/105] 8374683: ZGC: Convert zLock to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zLock.hpp | 9 +++++---- src/hotspot/share/gc/z/zLock.inline.hpp | 11 +++++------ 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/hotspot/share/gc/z/zLock.hpp b/src/hotspot/share/gc/z/zLock.hpp index 640a9fb02d3..a843f2389d7 100644 --- a/src/hotspot/share/gc/z/zLock.hpp +++ b/src/hotspot/share/gc/z/zLock.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -25,6 +25,7 @@ #define SHARE_GC_Z_ZLOCK_HPP #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" #include "runtime/mutex.hpp" class ZLock : public CHeapObj { @@ -39,9 +40,9 @@ public: class ZReentrantLock { private: - ZLock _lock; - Thread* volatile _owner; - uint64_t _count; + ZLock _lock; + Atomic _owner; + uint64_t _count; public: ZReentrantLock(); diff --git a/src/hotspot/share/gc/z/zLock.inline.hpp b/src/hotspot/share/gc/z/zLock.inline.hpp index edf59be5b4c..ba5d6692521 100644 --- a/src/hotspot/share/gc/z/zLock.inline.hpp +++ b/src/hotspot/share/gc/z/zLock.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -26,7 +26,6 @@ #include "gc/z/zLock.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/javaThread.hpp" #include "runtime/os.inline.hpp" #include "utilities/debug.hpp" @@ -50,11 +49,11 @@ inline ZReentrantLock::ZReentrantLock() inline void ZReentrantLock::lock() { Thread* const thread = Thread::current(); - Thread* const owner = AtomicAccess::load(&_owner); + Thread* const owner = _owner.load_relaxed(); if (owner != thread) { _lock.lock(); - AtomicAccess::store(&_owner, thread); + _owner.store_relaxed(thread); } _count++; @@ -67,14 +66,14 @@ inline void ZReentrantLock::unlock() { _count--; if (_count == 0) { - AtomicAccess::store(&_owner, (Thread*)nullptr); + _owner.store_relaxed(nullptr); _lock.unlock(); } } inline bool ZReentrantLock::is_owned() const { Thread* const thread = Thread::current(); - Thread* const owner = AtomicAccess::load(&_owner); + Thread* const owner = _owner.load_relaxed(); return owner == thread; } From f4607ed0a7ea2504c1d72dd3dab0b21e583fa0e7 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Mon, 26 Jan 2026 15:35:59 +0000 Subject: [PATCH 056/105] 8374684: ZGC: Convert zMark to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zMark.cpp | 16 ++++++++-------- src/hotspot/share/gc/z/zMark.hpp | 7 ++++--- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/src/hotspot/share/gc/z/zMark.cpp b/src/hotspot/share/gc/z/zMark.cpp index 3b247fdd35e..03701ae9998 100644 --- a/src/hotspot/share/gc/z/zMark.cpp +++ b/src/hotspot/share/gc/z/zMark.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -57,7 +57,6 @@ #include "memory/iterator.inline.hpp" #include "oops/objArrayOop.inline.hpp" #include "oops/oop.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/continuation.hpp" #include "runtime/handshake.hpp" #include "runtime/javaThread.hpp" @@ -152,13 +151,14 @@ void ZMark::prepare_work() { _terminate.reset(_nworkers); // Reset flush counters - _work_nproactiveflush = _work_nterminateflush = 0; + _work_nproactiveflush.store_relaxed(0u); + _work_nterminateflush.store_relaxed(0u); } void ZMark::finish_work() { // Accumulate proactive/terminate flush counters - _nproactiveflush += _work_nproactiveflush; - _nterminateflush += _work_nterminateflush; + _nproactiveflush += _work_nproactiveflush.load_relaxed(); + _nterminateflush += _work_nterminateflush.load_relaxed(); } void ZMark::follow_work_complete() { @@ -594,7 +594,7 @@ bool ZMark::flush() { } bool ZMark::try_terminate_flush() { - AtomicAccess::inc(&_work_nterminateflush); + _work_nterminateflush.add_then_fetch(1u); _terminate.set_resurrected(false); if (ZVerifyMarking) { @@ -610,12 +610,12 @@ bool ZMark::try_proactive_flush() { return false; } - if (AtomicAccess::load(&_work_nproactiveflush) == ZMarkProactiveFlushMax) { + if (_work_nproactiveflush.load_relaxed() == ZMarkProactiveFlushMax) { // Limit reached or we're trying to terminate return false; } - AtomicAccess::inc(&_work_nproactiveflush); + _work_nproactiveflush.add_then_fetch(1u); SuspendibleThreadSetLeaver sts_leaver; return flush(); diff --git a/src/hotspot/share/gc/z/zMark.hpp b/src/hotspot/share/gc/z/zMark.hpp index cc398addeb8..72a527b957d 100644 --- a/src/hotspot/share/gc/z/zMark.hpp +++ b/src/hotspot/share/gc/z/zMark.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -30,6 +30,7 @@ #include "gc/z/zMarkStackEntry.hpp" #include "gc/z/zMarkTerminate.hpp" #include "oops/oopsHierarchy.hpp" +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" class Thread; @@ -60,8 +61,8 @@ private: ZMarkingSMR _marking_smr; ZMarkStripeSet _stripes; ZMarkTerminate _terminate; - volatile size_t _work_nproactiveflush; - volatile size_t _work_nterminateflush; + Atomic _work_nproactiveflush; + Atomic _work_nterminateflush; size_t _nproactiveflush; size_t _nterminateflush; size_t _ntrycomplete; From bbae38e510efd8877daca5118f45893bb87f6eaa Mon Sep 17 00:00:00 2001 From: Christian Hagedorn Date: Mon, 26 Jan 2026 16:23:30 +0000 Subject: [PATCH 057/105] 8375272: [IR Framework] Miscellaneous clean-ups Reviewed-by: mchevalier, dfenacci, thartmann --- src/hotspot/share/opto/compile.cpp | 26 +++---- src/hotspot/share/opto/compile.hpp | 6 +- .../lib/ir_framework/CompilePhase.java | 4 +- .../lib/ir_framework/TestFramework.java | 14 ++-- .../ir_framework/driver/TestVMProcess.java | 3 +- .../driver/irmatching/irmethod/IRMethod.java | 16 ++--- .../irmethod/NotCompilableIRMethod.java | 5 +- .../NotCompilableIRMethodMatchResult.java | 5 +- .../parser/ApplicableIRRulesParser.java | 39 ++++++----- .../irmatching/parser/IRMethodBuilder.java | 4 +- .../driver/irmatching/parser/TestMethod.java | 7 +- .../driver/network/testvm/java/IRRuleIds.java | 68 +++++++++++++++++++ .../lib/ir_framework/test/TestVM.java | 14 ++-- .../ir_framework/tests/TestCheckedTests.java | 14 ++-- .../ir_framework/tests/TestSetupTests.java | 12 ++-- 15 files changed, 153 insertions(+), 84 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/lib/ir_framework/driver/network/testvm/java/IRRuleIds.java diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp index cea2b09e142..7d99f4a7336 100644 --- a/src/hotspot/share/opto/compile.cpp +++ b/src/hotspot/share/opto/compile.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -581,7 +581,7 @@ void Compile::print_phase(const char* phase_name) { tty->print_cr("%u.\t%s", ++_phase_counter, phase_name); } -void Compile::print_ideal_ir(const char* phase_name) { +void Compile::print_ideal_ir(const char* compile_phase_name) const { // keep the following output all in one block // This output goes directly to the tty, not the compiler log. // To enable tools to match it up with the compilation activity, @@ -593,7 +593,7 @@ void Compile::print_ideal_ir(const char* phase_name) { stringStream ss; if (_output == nullptr) { - ss.print_cr("AFTER: %s", phase_name); + ss.print_cr("AFTER: %s", compile_phase_name); // Print out all nodes in ascending order of index. // It is important that we traverse both inputs and outputs of nodes, // so that we reach all nodes that are connected to Root. @@ -610,7 +610,7 @@ void Compile::print_ideal_ir(const char* phase_name) { xtty->head("ideal compile_id='%d'%s compile_phase='%s'", compile_id(), is_osr_compilation() ? " compile_kind='osr'" : "", - phase_name); + compile_phase_name); } tty->print("%s", ss.as_string()); @@ -671,7 +671,7 @@ Compile::Compile(ciEnv* ci_env, ciMethod* target, int osr_bci, _coarsened_locks(comp_arena(), 8, 0, nullptr), _congraph(nullptr), NOT_PRODUCT(_igv_printer(nullptr) COMMA) - _unique(0), + _unique(0), _dead_node_count(0), _dead_node_list(comp_arena()), _node_arena_one(mtCompiler, Arena::Tag::tag_node), @@ -865,7 +865,7 @@ Compile::Compile(ciEnv* ci_env, ciMethod* target, int osr_bci, #ifndef PRODUCT if (should_print_ideal()) { - print_ideal_ir("print_ideal"); + print_ideal_ir("PrintIdeal"); } #endif @@ -938,7 +938,7 @@ Compile::Compile(ciEnv* ci_env, _for_merge_stores_igvn(comp_arena(), 8, 0, nullptr), _congraph(nullptr), NOT_PRODUCT(_igv_printer(nullptr) COMMA) - _unique(0), + _unique(0), _dead_node_count(0), _dead_node_list(comp_arena()), _node_arena_one(mtCompiler, Arena::Tag::tag_node), @@ -5165,17 +5165,17 @@ void Compile::sort_macro_nodes() { } } -void Compile::print_method(CompilerPhaseType cpt, int level, Node* n) { +void Compile::print_method(CompilerPhaseType compile_phase, int level, Node* n) { if (failing_internal()) { return; } // failing_internal to not stress bailouts from printing code. EventCompilerPhase event(UNTIMED); if (event.should_commit()) { - CompilerEvent::PhaseEvent::post(event, C->_latest_stage_start_counter, cpt, C->_compile_id, level); + CompilerEvent::PhaseEvent::post(event, C->_latest_stage_start_counter, compile_phase, C->_compile_id, level); } #ifndef PRODUCT ResourceMark rm; stringStream ss; - ss.print_raw(CompilerPhaseTypeHelper::to_description(cpt)); - int iter = ++_igv_phase_iter[cpt]; + ss.print_raw(CompilerPhaseTypeHelper::to_description(compile_phase)); + int iter = ++_igv_phase_iter[compile_phase]; if (iter > 1) { ss.print(" %d", iter); } @@ -5203,8 +5203,8 @@ void Compile::print_method(CompilerPhaseType cpt, int level, Node* n) { if (should_print_phase(level)) { print_phase(name); } - if (should_print_ideal_phase(cpt)) { - print_ideal_ir(CompilerPhaseTypeHelper::to_name(cpt)); + if (should_print_ideal_phase(compile_phase)) { + print_ideal_ir(CompilerPhaseTypeHelper::to_name(compile_phase)); } #endif C->_latest_stage_start_counter.stamp(); diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp index 45a3a4f548f..12812424f5e 100644 --- a/src/hotspot/share/opto/compile.hpp +++ b/src/hotspot/share/opto/compile.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -666,7 +666,7 @@ public: uint next_igv_idx() { return _igv_idx++; } bool trace_opto_output() const { return _trace_opto_output; } void print_phase(const char* phase_name); - void print_ideal_ir(const char* phase_name); + void print_ideal_ir(const char* compile_phase_name) const; bool should_print_ideal() const { return _directive->PrintIdealOption; } bool parsed_irreducible_loop() const { return _parsed_irreducible_loop; } void set_parsed_irreducible_loop(bool z) { _parsed_irreducible_loop = z; } @@ -680,7 +680,7 @@ public: void begin_method(); void end_method(); - void print_method(CompilerPhaseType cpt, int level, Node* n = nullptr); + void print_method(CompilerPhaseType compile_phase, int level, Node* n = nullptr); #ifndef PRODUCT bool should_print_igv(int level); diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java b/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java index a536808d269..1e3ba7c314e 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, 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 @@ -161,7 +161,7 @@ public enum CompilePhase { static { for (CompilePhase phase : CompilePhase.values()) { if (phase == PRINT_IDEAL) { - PHASES_BY_PARSED_NAME.put("print_ideal", phase); + PHASES_BY_PARSED_NAME.put("PrintIdeal", phase); } else { PHASES_BY_PARSED_NAME.put(phase.name(), phase); } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/TestFramework.java b/test/hotspot/jtreg/compiler/lib/ir_framework/TestFramework.java index 1fea5da52ef..137efd18136 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/TestFramework.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/TestFramework.java @@ -183,7 +183,7 @@ public class TestFramework { private List flags; private int defaultWarmup = -1; private boolean testClassesOnBootClassPath; - private boolean isAllowNotCompilable = false; + private boolean allowNotCompilable = false; /* * Public interface methods @@ -498,7 +498,7 @@ public class TestFramework { * and else it is ignored silently. */ public TestFramework allowNotCompilable() { - this.isAllowNotCompilable = true; + this.allowNotCompilable = true; return this; } @@ -721,7 +721,7 @@ public class TestFramework { nonWhiteListedFlags.forEach((f) -> System.out.println(" - " + f)); } - System.out.println(""); + System.out.println(); } /** @@ -860,8 +860,8 @@ public class TestFramework { private List anyNonWhitelistedJTregVMAndJavaOptsFlags() { List flags = Arrays.stream(Utils.getTestJavaOpts()) .map(s -> s.replaceFirst("-XX:[+|-]?|-(?=[^D|^e])", "")) - .collect(Collectors.toList()); - List nonWhiteListedFlags = new ArrayList(); + .toList(); + List nonWhiteListedFlags = new ArrayList<>(); for (String flag : flags) { if (flag.contains("agentpath")) { throw new SkippedException("Can't run test with -javaagent"); @@ -877,10 +877,10 @@ public class TestFramework { private void runTestVM(List additionalFlags) { TestVMProcess testVMProcess = new TestVMProcess(additionalFlags, testClass, helperClasses, defaultWarmup, - isAllowNotCompilable, testClassesOnBootClassPath); + allowNotCompilable, testClassesOnBootClassPath); if (shouldVerifyIR) { try { - TestClassParser testClassParser = new TestClassParser(testClass, isAllowNotCompilable); + TestClassParser testClassParser = new TestClassParser(testClass, allowNotCompilable); Matchable testClassMatchable = testClassParser.parse(testVMProcess.getHotspotPidFileName(), testVMProcess.getApplicableIRRules()); IRMatcher matcher = new IRMatcher(testClassMatchable); diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/TestVMProcess.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/TestVMProcess.java index a172dce1991..931d687b0bc 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/TestVMProcess.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/TestVMProcess.java @@ -38,7 +38,6 @@ import java.io.File; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; -import java.util.stream.Collectors; /** * This class prepares, creates, and runs the Test VM with verification of proper termination. The class also stores @@ -108,7 +107,7 @@ public class TestVMProcess { cmds.add("-XX:+UnlockDiagnosticVMOptions"); cmds.add("-XX:+WhiteBoxAPI"); // Ignore CompileCommand flags which have an impact on the profiling information. - List jtregVMFlags = Arrays.stream(Utils.getTestJavaOpts()).filter(s -> !s.contains("CompileThreshold")).collect(Collectors.toList()); + List jtregVMFlags = Arrays.stream(Utils.getTestJavaOpts()).filter(s -> !s.contains("CompileThreshold")).toList(); if (!PREFER_COMMAND_LINE_FLAGS) { cmds.addAll(jtregVMFlags); } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/IRMethod.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/IRMethod.java index 714af5c6519..893312c5196 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/IRMethod.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/IRMethod.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -32,6 +32,7 @@ import compiler.lib.ir_framework.driver.irmatching.Matchable; import compiler.lib.ir_framework.driver.irmatching.MatchableMatcher; import compiler.lib.ir_framework.driver.irmatching.irrule.IRRule; import compiler.lib.ir_framework.driver.irmatching.parser.VMInfo; +import compiler.lib.ir_framework.driver.network.testvm.java.IRRuleIds; import compiler.lib.ir_framework.shared.TestFormat; import compiler.lib.ir_framework.shared.TestFormatException; @@ -53,14 +54,14 @@ public class IRMethod implements IRMethodMatchable { private final Method method; private final MatchableMatcher matcher; - public IRMethod(Method method, int[] ruleIds, IR[] irAnnos, Compilation compilation, VMInfo vmInfo) { + public IRMethod(Method method, IRRuleIds irRuleIds, IR[] irAnnos, Compilation compilation, VMInfo vmInfo) { this.method = method; - this.matcher = new MatchableMatcher(createIRRules(method, ruleIds, irAnnos, compilation, vmInfo)); + this.matcher = new MatchableMatcher(createIRRules(method, irRuleIds, irAnnos, compilation, vmInfo)); } - private List createIRRules(Method method, int[] ruleIds, IR[] irAnnos, Compilation compilation, VMInfo vmInfo) { + private List createIRRules(Method method, IRRuleIds irRuleIds, IR[] irAnnos, Compilation compilation, VMInfo vmInfo) { List irRules = new ArrayList<>(); - for (int ruleId : ruleIds) { + for (int ruleId : irRuleIds) { try { irRules.add(new IRRule(ruleId, irAnnos[ruleId - 1], compilation, vmInfo)); } catch (TestFormatException e) { @@ -89,13 +90,12 @@ public class IRMethod implements IRMethodMatchable { return new IRMethodMatchResult(method, matcher.match()); } - List match; for (int i = 0; i < 10; i++) { // warm up - match = matcher.match(); + matcher.match(); } long startTime = System.nanoTime(); - match = matcher.match(); + List match = matcher.match(); long endTime = System.nanoTime(); long duration = (endTime - startTime); System.out.println("Verifying IR rules for " + name() + ": " + duration + " ns = " + (duration / 1000000) + " ms"); diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethod.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethod.java index d74825c8d4f..cb99ea219fe 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethod.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethod.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -24,8 +24,7 @@ package compiler.lib.ir_framework.driver.irmatching.irmethod; import compiler.lib.ir_framework.IR; -import compiler.lib.ir_framework.Run; -import compiler.lib.ir_framework.RunMode; +import compiler.lib.ir_framework.Test; import java.lang.reflect.Method; diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethodMatchResult.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethodMatchResult.java index 011b596cc9e..bea8dc3ab27 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethodMatchResult.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irmethod/NotCompilableIRMethodMatchResult.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -23,8 +23,7 @@ package compiler.lib.ir_framework.driver.irmatching.irmethod; -import compiler.lib.ir_framework.Run; -import compiler.lib.ir_framework.RunMode; +import compiler.lib.ir_framework.Test; import compiler.lib.ir_framework.driver.irmatching.MatchResult; import compiler.lib.ir_framework.driver.irmatching.visitor.MatchResultVisitor; diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/ApplicableIRRulesParser.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/ApplicableIRRulesParser.java index 7aaf0c2b285..be44c3f3d91 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/ApplicableIRRulesParser.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/ApplicableIRRulesParser.java @@ -26,12 +26,15 @@ package compiler.lib.ir_framework.driver.irmatching.parser; import compiler.lib.ir_framework.IR; import compiler.lib.ir_framework.TestFramework; import compiler.lib.ir_framework.driver.irmatching.parser.hotspot.HotSpotPidFileParser; +import compiler.lib.ir_framework.driver.network.testvm.java.IRRuleIds; import compiler.lib.ir_framework.shared.TestFormat; import compiler.lib.ir_framework.shared.TestFrameworkException; import compiler.lib.ir_framework.test.ApplicableIRRulesPrinter; import java.lang.reflect.Method; +import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -75,15 +78,15 @@ public class ApplicableIRRulesParser { * assembly output in {@link HotSpotPidFileParser}. */ private void createTestMethodMap(String applicableIRRules, Class testClass) { - Map irRulesMap = parseApplicableIRRules(applicableIRRules); + Map irRulesMap = parseApplicableIRRules(applicableIRRules); createTestMethodsWithApplicableIRRules(testClass, irRulesMap); } /** * Read the Applicable IR Rules emitted by the Test VM to decide if an @IR rule must be checked for a method. */ - private Map parseApplicableIRRules(String applicableIRRules) { - Map irRulesMap = new HashMap<>(); + private Map parseApplicableIRRules(String applicableIRRules) { + Map irRulesMap = new HashMap<>(); String[] applicableIRRulesLines = getApplicableIRRulesLines(applicableIRRules); for (String s : applicableIRRulesLines) { String line = s.trim(); @@ -92,8 +95,8 @@ public class ApplicableIRRulesParser { throw new TestFrameworkException("Invalid Applicable IR Rules format. No comma found: " + splitLine[0]); } String testName = splitLine[0]; - int[] irRulesIdx = getRuleIndexes(splitLine); - irRulesMap.put(testName, irRulesIdx); + IRRuleIds irRuleIds = parseIrRulesIds(splitLine); + irRulesMap.put(testName, irRuleIds); } return irRulesMap; } @@ -116,24 +119,24 @@ public class ApplicableIRRulesParser { /** * Parse rule indexes from a single line of the Applicable IR Rules in the format: */ - private int[] getRuleIndexes(String[] splitLine) { - int[] irRulesIdx = new int[splitLine.length - 1]; + private IRRuleIds parseIrRulesIds(String[] splitLine) { + List irRuleIds = new ArrayList<>(); for (int i = 1; i < splitLine.length; i++) { try { - irRulesIdx[i - 1] = Integer.parseInt(splitLine[i]); + irRuleIds.add(Integer.parseInt(splitLine[i])); } catch (NumberFormatException e) { throw new TestFrameworkException("Invalid Applicable IR Rules format. No number found: " + splitLine[i]); } } - return irRulesIdx; + return new IRRuleIds(irRuleIds); } - private void createTestMethodsWithApplicableIRRules(Class testClass, Map irRulesMap) { + private void createTestMethodsWithApplicableIRRules(Class testClass, Map irRulesMap) { for (Method m : testClass.getDeclaredMethods()) { IR[] irAnnos = m.getAnnotationsByType(IR.class); if (irAnnos.length > 0) { // Validation of legal @IR attributes and placement of the annotation was already done in Test VM. - int[] irRuleIds = irRulesMap.get(m.getName()); + IRRuleIds irRuleIds = irRulesMap.get(m.getName()); validateIRRuleIds(m, irAnnos, irRuleIds); if (hasAnyApplicableIRRules(irRuleIds)) { testMethods.put(m.getName(), new TestMethod(m, irAnnos, irRuleIds)); @@ -142,18 +145,18 @@ public class ApplicableIRRulesParser { } } - private void validateIRRuleIds(Method m, IR[] irAnnos, int[] ids) { - TestFramework.check(ids != null, "Should find method name in validIrRulesMap for " + m); - TestFramework.check(ids.length > 0, "Did not find any rule indices for " + m); - TestFramework.check((ids[0] >= 1 || ids[0] == ApplicableIRRulesPrinter.NO_RULE_APPLIED) - && ids[ids.length - 1] <= irAnnos.length, + private void validateIRRuleIds(Method m, IR[] irAnnos, IRRuleIds irRuleIds) { + TestFramework.check(irRuleIds != null, "Should find method name in validIrRulesMap for " + m); + TestFramework.check(!irRuleIds.isEmpty(), "Did not find any rule indices for " + m); + TestFramework.check((irRuleIds.first() >= 1 || irRuleIds.first() == ApplicableIRRulesPrinter.NO_RULE_APPLIED) + && irRuleIds.last() <= irAnnos.length, "Invalid IR rule index found in validIrRulesMap for " + m); } /** * Does the list of IR rules contain any applicable IR rules for the given conditions? */ - private boolean hasAnyApplicableIRRules(int[] irRuleIds) { - return irRuleIds[0] != ApplicableIRRulesPrinter.NO_RULE_APPLIED; + private boolean hasAnyApplicableIRRules(IRRuleIds irRuleIds) { + return irRuleIds.first() != ApplicableIRRulesPrinter.NO_RULE_APPLIED; } } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/IRMethodBuilder.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/IRMethodBuilder.java index d7a10acd1cd..46a237576e6 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/IRMethodBuilder.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/IRMethodBuilder.java @@ -71,9 +71,9 @@ class IRMethodBuilder { Test[] testAnnos = testMethod.method().getAnnotationsByType(Test.class); boolean allowMethodNotCompilable = allowNotCompilable || testAnnos[0].allowNotCompilable(); if (allowMethodNotCompilable) { - return new NotCompilableIRMethod(testMethod.method(), testMethod.irRuleIds().length); + return new NotCompilableIRMethod(testMethod.method(), testMethod.irRuleIds().count()); } else { - return new NotCompiledIRMethod(testMethod.method(), testMethod.irRuleIds().length); + return new NotCompiledIRMethod(testMethod.method(), testMethod.irRuleIds().count()); } } } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/TestMethod.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/TestMethod.java index 43f27c80ac6..37989d8810b 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/TestMethod.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/TestMethod.java @@ -26,6 +26,7 @@ package compiler.lib.ir_framework.driver.irmatching.parser; import compiler.lib.ir_framework.IR; import compiler.lib.ir_framework.driver.irmatching.irmethod.IRMethod; import compiler.lib.ir_framework.driver.irmatching.parser.hotspot.LoggedMethod; +import compiler.lib.ir_framework.driver.network.testvm.java.IRRuleIds; import java.lang.reflect.Method; @@ -40,9 +41,9 @@ import java.lang.reflect.Method; public class TestMethod { private final Method method; private final IR[] irAnnos; - private final int[] irRuleIds; + private final IRRuleIds irRuleIds; - public TestMethod(Method m, IR[] irAnnos, int[] irRuleIds) { + public TestMethod(Method m, IR[] irAnnos, IRRuleIds irRuleIds) { this.method = m; this.irAnnos = irAnnos; this.irRuleIds = irRuleIds; @@ -56,7 +57,7 @@ public class TestMethod { return irAnnos; } - public int[] irRuleIds() { + public IRRuleIds irRuleIds() { return irRuleIds; } } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/network/testvm/java/IRRuleIds.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/network/testvm/java/IRRuleIds.java new file mode 100644 index 00000000000..b8ea1765b4f --- /dev/null +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/network/testvm/java/IRRuleIds.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2026, 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. + */ + +package compiler.lib.ir_framework.driver.network.testvm.java; + +import compiler.lib.ir_framework.IR; +import compiler.lib.ir_framework.driver.irmatching.irmethod.IRMethod; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Stream; + +/** + * Class to hold the indices of the applicable {@link IR @IR} rules of an {@link IRMethod}. + */ +public class IRRuleIds implements Iterable { + private final List ruleIds; + + public IRRuleIds(List ruleIds) { + this.ruleIds = ruleIds; + } + + public int first() { + return ruleIds.getFirst(); + } + + public int last() { + return ruleIds.getLast(); + } + + public boolean isEmpty() { + return ruleIds.isEmpty(); + } + + public int count() { + return ruleIds.size(); + } + + @Override + public Iterator iterator() { + return ruleIds.iterator(); + } + + public Stream stream() { + return ruleIds.stream(); + } +} diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/test/TestVM.java b/test/hotspot/jtreg/compiler/lib/ir_framework/test/TestVM.java index c5ab318d67d..c2580e087f0 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/test/TestVM.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/test/TestVM.java @@ -92,7 +92,7 @@ public class TestVM { static final boolean XCOMP = Platform.isComp(); static final boolean VERBOSE = Boolean.getBoolean("Verbose"); - private static final boolean PRINT_TIMES = Boolean.getBoolean("PrintTimes"); + private static final boolean PRINT_TIMES = Boolean.getBoolean("PrintTimes") || VERBOSE; public static final boolean USE_COMPILER = WHITE_BOX.getBooleanVMFlag("UseCompiler"); static final boolean EXCLUDE_RANDOM = Boolean.getBoolean("ExcludeRandom"); private static final String TESTLIST = System.getProperty("Test", ""); @@ -823,14 +823,14 @@ public class TestVM { forceCompileMap.forEach((key, value) -> builder.append("- ").append(key).append(" at CompLevel.").append(value) .append(System.lineSeparator())); throw new TestRunException("Could not force compile the following @ForceCompile methods:" - + System.lineSeparator() + builder.toString()); + + System.lineSeparator() + builder); } /** * Once all framework tests are collected, they are run in this method. */ private void runTests() { - TreeMap durations = (PRINT_TIMES || VERBOSE) ? new TreeMap<>() : null; + TreeMap durations = PRINT_TIMES ? new TreeMap<>() : null; long startTime = System.nanoTime(); List testList; boolean testFilterPresent = testFilterPresent(); @@ -867,11 +867,11 @@ public class TestVM { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); e.printStackTrace(pw); - builder.append(test.toString()).append(":").append(System.lineSeparator()).append(sw.toString()) + builder.append(test).append(":").append(System.lineSeparator()).append(sw) .append(System.lineSeparator()).append(System.lineSeparator()); failures++; } - if (PRINT_TIMES || VERBOSE) { + if (PRINT_TIMES) { long endTime = System.nanoTime(); long duration = (endTime - startTime); durations.put(duration, test.getName()); @@ -886,7 +886,7 @@ public class TestVM { } // Print execution times - if (VERBOSE || PRINT_TIMES) { + if (PRINT_TIMES) { TestFrameworkSocket.write("Test execution times:", PRINT_TIMES_TAG, true); for (Map.Entry entry : durations.entrySet()) { TestFrameworkSocket.write(String.format("%-25s%15d ns%n", entry.getValue() + ":", entry.getKey()), @@ -898,7 +898,7 @@ public class TestVM { // Finally, report all occurred exceptions in a nice format. String msg = System.lineSeparator() + System.lineSeparator() + "Test Failures (" + failures + ")" + System.lineSeparator() + "----------------" + "-".repeat(String.valueOf(failures).length()); - throw new TestRunException(msg + System.lineSeparator() + builder.toString()); + throw new TestRunException(msg + System.lineSeparator() + builder); } } diff --git a/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestCheckedTests.java b/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestCheckedTests.java index 5b7cd3c38a8..d4c12de3e4b 100644 --- a/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestCheckedTests.java +++ b/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestCheckedTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -180,6 +180,12 @@ class BadIRAndRuntimeCheckedTests { throw new BadCheckedTestException("expected"); } } + + static class BadCheckedTestException extends RuntimeException { + BadCheckedTestException(String s) { + super(s); + } + } } class BadIRCheckedTests { @@ -224,9 +230,3 @@ class BadIRCheckedTests { } } } - -class BadCheckedTestException extends RuntimeException { - BadCheckedTestException(String s) { - super(s); - } -} diff --git a/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestSetupTests.java b/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestSetupTests.java index 782a773515a..1cdb6c2797a 100644 --- a/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestSetupTests.java +++ b/test/hotspot/jtreg/testlibrary_tests/ir_framework/tests/TestSetupTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, 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 @@ -25,7 +25,6 @@ package ir_framework.tests; import compiler.lib.ir_framework.*; import compiler.lib.ir_framework.driver.TestVMException; -import compiler.lib.ir_framework.shared.TestRunException; import java.io.ByteArrayOutputStream; import java.io.PrintStream; @@ -360,10 +359,11 @@ class TestSetupTestsWithExpectedExceptions { public void checkThrowInCheck(int x) { throw new BadCheckedTestException("expected check"); } -} -class BadCheckedTestException extends RuntimeException { - BadCheckedTestException(String s) { - super(s); + + static class BadCheckedTestException extends RuntimeException { + BadCheckedTestException(String s) { + super(s); + } } } From 67beb9cd812db2af49c62c95d69f2f27d0a20af8 Mon Sep 17 00:00:00 2001 From: Henry Jen Date: Mon, 26 Jan 2026 16:38:12 +0000 Subject: [PATCH 058/105] 8373924: Remove unreferenced ImageDecompressor::image_decompressor_close Reviewed-by: alanb --- src/java.base/share/native/libjimage/imageDecompressor.cpp | 6 +----- src/java.base/share/native/libjimage/imageDecompressor.hpp | 5 +++-- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/java.base/share/native/libjimage/imageDecompressor.cpp b/src/java.base/share/native/libjimage/imageDecompressor.cpp index 748bbf8203f..4946e645c55 100644 --- a/src/java.base/share/native/libjimage/imageDecompressor.cpp +++ b/src/java.base/share/native/libjimage/imageDecompressor.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -85,10 +85,6 @@ void ImageDecompressor::image_decompressor_init() { } } -void ImageDecompressor::image_decompressor_close() { - delete[] _decompressors; -} - /* * Locate decompressor. */ diff --git a/src/java.base/share/native/libjimage/imageDecompressor.hpp b/src/java.base/share/native/libjimage/imageDecompressor.hpp index 16f354935c3..057fa15917c 100644 --- a/src/java.base/share/native/libjimage/imageDecompressor.hpp +++ b/src/java.base/share/native/libjimage/imageDecompressor.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -105,6 +105,7 @@ private: protected: ImageDecompressor(const char* name) : _name(name) { } + virtual void decompress_resource(u1* data, u1* uncompressed, ResourceHeader* header, const ImageStrings* strings) = 0; @@ -166,6 +167,6 @@ private: public: SharedStringDecompressor(const char* sym) : ImageDecompressor(sym){} void decompress_resource(u1* data, u1* uncompressed, ResourceHeader* header, - const ImageStrings* strings); + const ImageStrings* strings); }; #endif // LIBJIMAGE_IMAGEDECOMPRESSOR_HPP From b42861a2aa5bf5fde348cf17c5e40134148de1b4 Mon Sep 17 00:00:00 2001 From: Henry Jen Date: Mon, 26 Jan 2026 17:19:44 +0000 Subject: [PATCH 059/105] 8373699: JLink: ModuleReader should be closed in JlinkTask.getReleaseInfo(mref) Reviewed-by: alanb --- .../share/classes/jdk/tools/jlink/internal/JlinkTask.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JlinkTask.java b/src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JlinkTask.java index 825672cfe6d..3baae08eed6 100644 --- a/src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JlinkTask.java +++ b/src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JlinkTask.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -248,8 +248,8 @@ public class JlinkTask { * Read the release.txt from the module. */ private static Optional getReleaseInfo(ModuleReference mref) { - try { - Optional release = mref.open().open(JDK_RELEASE_RESOURCE); + try (var moduleReader = mref.open()) { + Optional release = moduleReader.open(JDK_RELEASE_RESOURCE); if (release.isEmpty()) { return Optional.empty(); From 3220c4cb431a2c4eb8bb2d60f0d5046e40af69bd Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Mon, 26 Jan 2026 18:32:15 +0000 Subject: [PATCH 060/105] 8372696: Allow boot classes to explicitly opt-in for final field trusting Reviewed-by: jvernee, jrose, alanb --- src/hotspot/share/ci/ciField.cpp | 12 ++-- src/hotspot/share/ci/ciInstanceKlass.cpp | 1 + src/hotspot/share/ci/ciInstanceKlass.hpp | 5 ++ .../share/classfile/classFileParser.cpp | 9 +++ src/hotspot/share/classfile/vmSymbols.hpp | 5 +- src/hotspot/share/oops/instanceKlass.hpp | 3 + src/hotspot/share/oops/instanceKlassFlags.hpp | 1 + .../share/classes/java/util/Optional.java | 4 +- .../atomic/AtomicIntegerFieldUpdater.java | 3 + .../atomic/AtomicLongFieldUpdater.java | 3 + .../atomic/AtomicReferenceFieldUpdater.java | 3 + .../vm/annotation/TrustFinalFields.java | 57 +++++++++++++++++ .../jtreg/compiler/corelibs/OptionalFold.java | 63 +++++++++++++++++++ 13 files changed, 155 insertions(+), 14 deletions(-) create mode 100644 src/java.base/share/classes/jdk/internal/vm/annotation/TrustFinalFields.java create mode 100644 test/hotspot/jtreg/compiler/corelibs/OptionalFold.java diff --git a/src/hotspot/share/ci/ciField.cpp b/src/hotspot/share/ci/ciField.cpp index 19e05784f4d..e0c818f02fc 100644 --- a/src/hotspot/share/ci/ciField.cpp +++ b/src/hotspot/share/ci/ciField.cpp @@ -216,6 +216,10 @@ ciField::ciField(fieldDescriptor *fd) : static bool trust_final_non_static_fields(ciInstanceKlass* holder) { if (holder == nullptr) return false; + if (holder->trust_final_fields()) { + // Explicit opt-in from system classes + return true; + } // Even if general trusting is disabled, trust system-built closures in these packages. if (holder->is_in_package("java/lang/invoke") || holder->is_in_package("sun/invoke") || holder->is_in_package("java/lang/reflect") || holder->is_in_package("jdk/internal/reflect") || @@ -230,14 +234,6 @@ static bool trust_final_non_static_fields(ciInstanceKlass* holder) { // Trust final fields in records if (holder->is_record()) return true; - // Trust Atomic*FieldUpdaters: they are very important for performance, and make up one - // more reason not to use Unsafe, if their final fields are trusted. See more in JDK-8140483. - if (holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() || - holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() || - holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() || - holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) { - return true; - } return TrustFinalNonStaticFields; } diff --git a/src/hotspot/share/ci/ciInstanceKlass.cpp b/src/hotspot/share/ci/ciInstanceKlass.cpp index 64b9acf9146..33bcabc4566 100644 --- a/src/hotspot/share/ci/ciInstanceKlass.cpp +++ b/src/hotspot/share/ci/ciInstanceKlass.cpp @@ -65,6 +65,7 @@ ciInstanceKlass::ciInstanceKlass(Klass* k) : _has_nonstatic_concrete_methods = ik->has_nonstatic_concrete_methods(); _is_hidden = ik->is_hidden(); _is_record = ik->is_record(); + _trust_final_fields = ik->trust_final_fields(); _nonstatic_fields = nullptr; // initialized lazily by compute_nonstatic_fields: _has_injected_fields = -1; _implementor = nullptr; // we will fill these lazily diff --git a/src/hotspot/share/ci/ciInstanceKlass.hpp b/src/hotspot/share/ci/ciInstanceKlass.hpp index a1b2d8dd12d..8ccf1fadfb7 100644 --- a/src/hotspot/share/ci/ciInstanceKlass.hpp +++ b/src/hotspot/share/ci/ciInstanceKlass.hpp @@ -59,6 +59,7 @@ private: bool _has_nonstatic_concrete_methods; bool _is_hidden; bool _is_record; + bool _trust_final_fields; bool _has_trusted_loader; ciFlags _flags; @@ -207,6 +208,10 @@ public: return _is_record; } + bool trust_final_fields() const { + return _trust_final_fields; + } + ciInstanceKlass* get_canonical_holder(int offset); ciField* get_field_by_offset(int field_offset, bool is_static); ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static); diff --git a/src/hotspot/share/classfile/classFileParser.cpp b/src/hotspot/share/classfile/classFileParser.cpp index c9d9d3632b5..817d0c64d11 100644 --- a/src/hotspot/share/classfile/classFileParser.cpp +++ b/src/hotspot/share/classfile/classFileParser.cpp @@ -943,6 +943,7 @@ public: _java_lang_Deprecated_for_removal, _jdk_internal_vm_annotation_AOTSafeClassInitializer, _method_AOTRuntimeSetup, + _jdk_internal_vm_annotation_TrustFinalFields, _annotation_LIMIT }; const Location _location; @@ -1878,6 +1879,11 @@ AnnotationCollector::annotation_index(const ClassLoaderData* loader_data, if (!privileged) break; // only allow in privileged code return _field_Stable; } + case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_TrustFinalFields_signature): { + if (_location != _in_class) break; // only allow for classes + if (!privileged) break; // only allow in privileged code + return _jdk_internal_vm_annotation_TrustFinalFields; + } case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Contended_signature): { if (_location != _in_field && _location != _in_class) { break; // only allow for fields and classes @@ -1992,6 +1998,9 @@ void ClassFileParser::ClassAnnotationCollector::apply_to(InstanceKlass* ik) { if (has_annotation(_jdk_internal_vm_annotation_AOTSafeClassInitializer)) { ik->set_has_aot_safe_initializer(); } + if (has_annotation(_jdk_internal_vm_annotation_TrustFinalFields)) { + ik->set_trust_final_fields(true); + } } #define MAX_ARGS_SIZE 255 diff --git a/src/hotspot/share/classfile/vmSymbols.hpp b/src/hotspot/share/classfile/vmSymbols.hpp index 8388b98faae..79646f24d0e 100644 --- a/src/hotspot/share/classfile/vmSymbols.hpp +++ b/src/hotspot/share/classfile/vmSymbols.hpp @@ -245,10 +245,6 @@ class SerializeClosure; \ /* Concurrency support */ \ template(java_util_concurrent_locks_AbstractOwnableSynchronizer, "java/util/concurrent/locks/AbstractOwnableSynchronizer") \ - template(java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl, "java/util/concurrent/atomic/AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl") \ - template(java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater, "java/util/concurrent/atomic/AtomicLongFieldUpdater$CASUpdater") \ - template(java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater, "java/util/concurrent/atomic/AtomicLongFieldUpdater$LockedUpdater") \ - template(java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl, "java/util/concurrent/atomic/AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl") \ template(jdk_internal_vm_annotation_Contended_signature, "Ljdk/internal/vm/annotation/Contended;") \ template(jdk_internal_vm_annotation_ReservedStackAccess_signature, "Ljdk/internal/vm/annotation/ReservedStackAccess;") \ template(jdk_internal_ValueBased_signature, "Ljdk/internal/ValueBased;") \ @@ -302,6 +298,7 @@ class SerializeClosure; template(jdk_internal_misc_Scoped_signature, "Ljdk/internal/misc/ScopedMemoryAccess$Scoped;") \ template(jdk_internal_vm_annotation_IntrinsicCandidate_signature, "Ljdk/internal/vm/annotation/IntrinsicCandidate;") \ template(jdk_internal_vm_annotation_Stable_signature, "Ljdk/internal/vm/annotation/Stable;") \ + template(jdk_internal_vm_annotation_TrustFinalFields_signature, "Ljdk/internal/vm/annotation/TrustFinalFields;") \ \ template(jdk_internal_vm_annotation_ChangesCurrentThread_signature, "Ljdk/internal/vm/annotation/ChangesCurrentThread;") \ template(jdk_internal_vm_annotation_JvmtiHideEvents_signature, "Ljdk/internal/vm/annotation/JvmtiHideEvents;") \ diff --git a/src/hotspot/share/oops/instanceKlass.hpp b/src/hotspot/share/oops/instanceKlass.hpp index 23a59d26093..e370a3b7a7c 100644 --- a/src/hotspot/share/oops/instanceKlass.hpp +++ b/src/hotspot/share/oops/instanceKlass.hpp @@ -353,6 +353,9 @@ class InstanceKlass: public Klass { int static_oop_field_count() const { return (int)_static_oop_field_count; } void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; } + bool trust_final_fields() { return _misc_flags.trust_final_fields(); } + void set_trust_final_fields(bool value) { _misc_flags.set_trust_final_fields(value); } + // Java itable int itable_length() const { return _itable_len; } void set_itable_length(int len) { _itable_len = len; } diff --git a/src/hotspot/share/oops/instanceKlassFlags.hpp b/src/hotspot/share/oops/instanceKlassFlags.hpp index 5eebaab27d1..d576805b30f 100644 --- a/src/hotspot/share/oops/instanceKlassFlags.hpp +++ b/src/hotspot/share/oops/instanceKlassFlags.hpp @@ -54,6 +54,7 @@ class InstanceKlassFlags { flag(has_localvariable_table , 1 << 11) /* has localvariable information */ \ flag(has_miranda_methods , 1 << 12) /* True if this class has miranda methods in it's vtable */ \ flag(has_final_method , 1 << 13) /* True if klass has final method */ \ + flag(trust_final_fields , 1 << 14) /* All instance final fields in this class should be trusted */ \ /* end of list */ #define IK_FLAGS_ENUM_NAME(name, value) _misc_##name = value, diff --git a/src/java.base/share/classes/java/util/Optional.java b/src/java.base/share/classes/java/util/Optional.java index 3e577bd379c..3d0375c4354 100644 --- a/src/java.base/share/classes/java/util/Optional.java +++ b/src/java.base/share/classes/java/util/Optional.java @@ -25,7 +25,7 @@ package java.util; -import jdk.internal.vm.annotation.Stable; +import jdk.internal.vm.annotation.TrustFinalFields; import java.util.function.Consumer; import java.util.function.Function; @@ -62,6 +62,7 @@ import java.util.stream.Stream; * @since 1.8 */ @jdk.internal.ValueBased +@TrustFinalFields public final class Optional { /** * Common instance for {@code empty()}. @@ -71,7 +72,6 @@ public final class Optional { /** * If non-null, the value; if null, indicates no value is present */ - @Stable private final T value; /** diff --git a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java index 2250009e8f5..70acb8a0889 100644 --- a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java +++ b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java @@ -42,6 +42,8 @@ import java.util.function.IntUnaryOperator; import jdk.internal.misc.Unsafe; import jdk.internal.reflect.CallerSensitive; import jdk.internal.reflect.Reflection; +import jdk.internal.vm.annotation.TrustFinalFields; + import java.lang.invoke.VarHandle; /** @@ -371,6 +373,7 @@ public abstract class AtomicIntegerFieldUpdater { /** * Standard hotspot implementation using intrinsics. */ + @TrustFinalFields private static final class AtomicIntegerFieldUpdaterImpl extends AtomicIntegerFieldUpdater { private static final Unsafe U = Unsafe.getUnsafe(); diff --git a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java index 5f0a666cb04..d3a3fe63d0f 100644 --- a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java +++ b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java @@ -42,6 +42,8 @@ import java.util.function.LongUnaryOperator; import jdk.internal.misc.Unsafe; import jdk.internal.reflect.CallerSensitive; import jdk.internal.reflect.Reflection; +import jdk.internal.vm.annotation.TrustFinalFields; + import java.lang.invoke.VarHandle; /** @@ -368,6 +370,7 @@ public abstract class AtomicLongFieldUpdater { return next; } + @TrustFinalFields private static final class CASUpdater extends AtomicLongFieldUpdater { private static final Unsafe U = Unsafe.getUnsafe(); private final long offset; diff --git a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java index 4a758f77a47..3d47e8e323a 100644 --- a/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java +++ b/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java @@ -42,6 +42,8 @@ import java.util.function.UnaryOperator; import jdk.internal.misc.Unsafe; import jdk.internal.reflect.CallerSensitive; import jdk.internal.reflect.Reflection; +import jdk.internal.vm.annotation.TrustFinalFields; + import java.lang.invoke.VarHandle; /** @@ -312,6 +314,7 @@ public abstract class AtomicReferenceFieldUpdater { return next; } + @TrustFinalFields private static final class AtomicReferenceFieldUpdaterImpl extends AtomicReferenceFieldUpdater { private static final Unsafe U = Unsafe.getUnsafe(); diff --git a/src/java.base/share/classes/jdk/internal/vm/annotation/TrustFinalFields.java b/src/java.base/share/classes/jdk/internal/vm/annotation/TrustFinalFields.java new file mode 100644 index 00000000000..a94f58159a2 --- /dev/null +++ b/src/java.base/share/classes/jdk/internal/vm/annotation/TrustFinalFields.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2025, 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ + +package jdk.internal.vm.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/// Indicates all instance final fields declared in the annotated class should +/// be trusted as constants by compilers in `ciField::is_constant`. +/// +/// The compiler already treats static final fields and instance final fields in +/// record classes and hidden classes as constant. All classes in select +/// packages (Defined in `trust_final_non_static_fields` in `ciField.cpp`) in +/// the boot class loader also have their instance final fields trusted. This +/// annotation is not necessary in these cases. +/// +/// The [Stable] annotation treats fields as constants once they are not the +/// zero or null value. In comparison, a non-stable final instance field +/// trusted by this annotation can treat zero and null values as constants. +/// +/// This annotation is suitable when constant treatment of final fields is +/// performance sensitive, yet package-wide final field constant treatment may +/// be at risk from final field modifications such as serialization. +/// +/// This annotation is only recognized on classes from the boot and platform +/// class loaders and is ignored elsewhere. +/// +/// @since 26 +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface TrustFinalFields { +} diff --git a/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java b/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java new file mode 100644 index 00000000000..0661a2e37e6 --- /dev/null +++ b/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2025, 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. + */ + +package compiler.corelibs; + +import java.util.Optional; + +import compiler.lib.ir_framework.Check; +import compiler.lib.ir_framework.IR; +import compiler.lib.ir_framework.IRNode; +import compiler.lib.ir_framework.Test; +import compiler.lib.ir_framework.TestFramework; + +/* + * @test + * @bug 8372696 + * @summary Verify constant folding for Optional, both present and absent + * @library /test/lib / + * @run driver ${test.main.class} + */ +public class OptionalFold { + + public static void main(String[] args) { + TestFramework.run(); + } + + // Ensure both present and empty values can fold + static final Optional ONE = Optional.of(5), TWO = Optional.empty(); + + @Test + @IR(failOn = {IRNode.ADD_I}) + public int testSum() { + return ONE.orElse(7) + TWO.orElse(12); + } + + @Check(test = "testSum") + public void checkTestSum(int res) { + if (res != 5 + 12) { + throw new RuntimeException("incorrect result: " + res); + } + } + +} From c69275ddfe8c1769ae82b4ba64b2d6d80bbd8683 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Mon, 26 Jan 2026 18:53:39 +0000 Subject: [PATCH 061/105] 8376232: Remove AppContext from Swing synth related classes Reviewed-by: serb, azvegint --- .../com/sun/java/swing/plaf/gtk/GTKStyle.java | 9 +- .../javax/swing/plaf/nimbus/Effect.java | 11 +- .../javax/swing/plaf/synth/ImagePainter.java | 16 +-- .../javax/swing/plaf/synth/Region.java | 24 ++-- .../javax/swing/plaf/synth/SynthButtonUI.java | 2 - .../swing/plaf/synth/SynthLookAndFeel.java | 51 ++----- .../swing/plaf/synth/7143614/bug7143614.java | 99 -------------- .../javax/swing/plaf/synth/Test6660049.java | 125 ------------------ 8 files changed, 30 insertions(+), 307 deletions(-) delete mode 100644 test/jdk/javax/swing/plaf/synth/7143614/bug7143614.java delete mode 100644 test/jdk/javax/swing/plaf/synth/Test6660049.java diff --git a/src/java.desktop/share/classes/com/sun/java/swing/plaf/gtk/GTKStyle.java b/src/java.desktop/share/classes/com/sun/java/swing/plaf/gtk/GTKStyle.java index baeb249eaa8..76d7abdbce6 100644 --- a/src/java.desktop/share/classes/com/sun/java/swing/plaf/gtk/GTKStyle.java +++ b/src/java.desktop/share/classes/com/sun/java/swing/plaf/gtk/GTKStyle.java @@ -32,7 +32,6 @@ import javax.swing.*; import javax.swing.plaf.*; import javax.swing.plaf.synth.*; -import sun.awt.AppContext; import sun.awt.UNIXToolkit; import sun.swing.SwingUtilities2; import javax.swing.plaf.synth.SynthIcon; @@ -961,11 +960,11 @@ class GTKStyle extends SynthStyle implements GTKConstants { static class GTKStockIconInfo { private static Map ICON_TYPE_MAP; - private static final Object ICON_SIZE_KEY = new StringBuffer("IconSize"); + + private static Dimension[] iconSizesMap; private static Dimension[] getIconSizesMap() { - AppContext appContext = AppContext.getAppContext(); - Dimension[] iconSizes = (Dimension[])appContext.get(ICON_SIZE_KEY); + Dimension[] iconSizes = iconSizesMap; if (iconSizes == null) { iconSizes = new Dimension[7]; @@ -976,7 +975,7 @@ class GTKStyle extends SynthStyle implements GTKConstants { iconSizes[4] = new Dimension(20, 20); // GTK_ICON_SIZE_BUTTON iconSizes[5] = new Dimension(32, 32); // GTK_ICON_SIZE_DND iconSizes[6] = new Dimension(48, 48); // GTK_ICON_SIZE_DIALOG - appContext.put(ICON_SIZE_KEY, iconSizes); + iconSizesMap = iconSizes; } return iconSizes; } diff --git a/src/java.desktop/share/classes/javax/swing/plaf/nimbus/Effect.java b/src/java.desktop/share/classes/javax/swing/plaf/nimbus/Effect.java index 30bed2207e4..d1b7ba143b3 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/nimbus/Effect.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/nimbus/Effect.java @@ -24,8 +24,6 @@ */ package javax.swing.plaf.nimbus; -import sun.awt.AppContext; - import java.awt.image.BufferedImage; import java.lang.ref.SoftReference; @@ -81,13 +79,10 @@ abstract class Effect { // ================================================================================================================= // Static data cache + private static final ArrayCache ARRAY_CACHE = new ArrayCache(); + protected static ArrayCache getArrayCache() { - ArrayCache cache = (ArrayCache)AppContext.getAppContext().get(ArrayCache.class); - if (cache == null){ - cache = new ArrayCache(); - AppContext.getAppContext().put(ArrayCache.class,cache); - } - return cache; + return ARRAY_CACHE; } protected static class ArrayCache { diff --git a/src/java.desktop/share/classes/javax/swing/plaf/synth/ImagePainter.java b/src/java.desktop/share/classes/javax/swing/plaf/synth/ImagePainter.java index 8a1d957b615..1171f64eb23 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/synth/ImagePainter.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/synth/ImagePainter.java @@ -28,7 +28,6 @@ import java.awt.*; import java.lang.ref.WeakReference; import java.net.*; import javax.swing.*; -import sun.awt.AppContext; import sun.swing.plaf.synth.Paint9Painter; /** @@ -41,8 +40,6 @@ import sun.swing.plaf.synth.Paint9Painter; * @author Scott Violet */ class ImagePainter extends SynthPainter { - private static final StringBuffer CACHE_KEY = - new StringBuffer("SynthCacheKey"); private Image image; private Insets sInsets; @@ -53,22 +50,17 @@ class ImagePainter extends SynthPainter { private Paint9Painter imageCache; private boolean center; + private static volatile WeakReference cacheRef; + private static Paint9Painter getPaint9Painter() { // A SynthPainter is created per . We want the - // cache to be shared by all, and we don't use a static because we - // don't want it to persist between look and feels. For that reason - // we use a AppContext specific Paint9Painter. It's backed via + // cache to be shared by all. It's held via // a WeakRef so that it can go away if the look and feel changes. - synchronized(CACHE_KEY) { - @SuppressWarnings("unchecked") - WeakReference cacheRef = - (WeakReference)AppContext.getAppContext(). - get(CACHE_KEY); + synchronized(ImagePainter.class) { Paint9Painter painter; if (cacheRef == null || (painter = cacheRef.get()) == null) { painter = new Paint9Painter(30); cacheRef = new WeakReference(painter); - AppContext.getAppContext().put(CACHE_KEY, cacheRef); } return painter; } diff --git a/src/java.desktop/share/classes/javax/swing/plaf/synth/Region.java b/src/java.desktop/share/classes/javax/swing/plaf/synth/Region.java index 5a59f3bb98d..f8a0800ff8b 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/synth/Region.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/synth/Region.java @@ -24,8 +24,6 @@ */ package javax.swing.plaf.synth; -import sun.awt.AppContext; - import java.util.HashMap; import java.util.Locale; import java.util.Map; @@ -72,8 +70,6 @@ import javax.swing.UIDefaults; * @author Scott Violet */ public class Region { - private static final Object UI_TO_REGION_MAP_KEY = new Object(); - private static final Object LOWER_CASE_NAME_MAP_KEY = new Object(); /** * ArrowButton's are special types of buttons that also render a @@ -425,10 +421,10 @@ public class Region { */ public static final Region VIEWPORT = new Region("Viewport", false); - private static Map getUItoRegionMap() { - AppContext context = AppContext.getAppContext(); - @SuppressWarnings("unchecked") - Map map = (Map) context.get(UI_TO_REGION_MAP_KEY); + private static Map regionMap; + + private static synchronized Map getUItoRegionMap() { + Map map = regionMap; if (map == null) { map = new HashMap(); map.put("ArrowButtonUI", ARROW_BUTTON); @@ -476,18 +472,18 @@ public class Region { map.put("ToolBarSeparatorUI", TOOL_BAR_SEPARATOR); map.put("TreeUI", TREE); map.put("ViewportUI", VIEWPORT); - context.put(UI_TO_REGION_MAP_KEY, map); + regionMap = map; } return map; } - private static Map getLowerCaseNameMap() { - AppContext context = AppContext.getAppContext(); - @SuppressWarnings("unchecked") - Map map = (Map) context.get(LOWER_CASE_NAME_MAP_KEY); + private static Map lcRegionMap; + + private static synchronized Map getLowerCaseNameMap() { + Map map = lcRegionMap; if (map == null) { map = new HashMap(); - context.put(LOWER_CASE_NAME_MAP_KEY, map); + lcRegionMap = map; } return map; } diff --git a/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthButtonUI.java b/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthButtonUI.java index 3a3d5719605..f0c7a9a1622 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthButtonUI.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthButtonUI.java @@ -25,8 +25,6 @@ package javax.swing.plaf.synth; -import sun.awt.AppContext; - import javax.swing.*; import java.awt.*; import java.beans.*; diff --git a/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthLookAndFeel.java b/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthLookAndFeel.java index 700e3ed8a38..095d675d3de 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthLookAndFeel.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/synth/SynthLookAndFeel.java @@ -60,7 +60,6 @@ import javax.swing.plaf.ComponentUI; import javax.swing.plaf.InsetsUIResource; import javax.swing.plaf.basic.BasicLookAndFeel; -import sun.awt.AppContext; import sun.awt.SunToolkit; import sun.swing.DefaultLookup; import sun.swing.SwingAccessor; @@ -101,31 +100,13 @@ public class SynthLookAndFeel extends BasicLookAndFeel { static final Insets EMPTY_UIRESOURCE_INSETS = new InsetsUIResource( 0, 0, 0, 0); - /** - * AppContext key to get the current SynthStyleFactory. - */ - private static final Object STYLE_FACTORY_KEY = - new StringBuffer("com.sun.java.swing.plaf.gtk.StyleCache"); + private static ComponentUI selectedUI; + private static int selectedUIStateValue; /** - * AppContext key to get selectedUI. - */ - private static final Object SELECTED_UI_KEY = new StringBuilder("selectedUI"); - - /** - * AppContext key to get selectedUIState. - */ - private static final Object SELECTED_UI_STATE_KEY = new StringBuilder("selectedUIState"); - - /** - * The last SynthStyleFactory that was asked for from AppContext - * lastContext. + * The last SynthStyleFactory that was set. */ private static SynthStyleFactory lastFactory; - /** - * AppContext lastLAF came from. - */ - private static AppContext lastContext; /** * SynthStyleFactory for the this SynthLookAndFeel. @@ -141,7 +122,7 @@ public class SynthLookAndFeel extends BasicLookAndFeel { private Handler _handler; static ComponentUI getSelectedUI() { - return (ComponentUI) AppContext.getAppContext().get(SELECTED_UI_KEY); + return selectedUI; } /** @@ -182,23 +163,20 @@ public class SynthLookAndFeel extends BasicLookAndFeel { } } - AppContext context = AppContext.getAppContext(); - - context.put(SELECTED_UI_KEY, uix); - context.put(SELECTED_UI_STATE_KEY, Integer.valueOf(selectedUIState)); + selectedUI = uix; + selectedUIStateValue = selectedUIState; } static int getSelectedUIState() { - Integer result = (Integer) AppContext.getAppContext().get(SELECTED_UI_STATE_KEY); - - return result == null ? 0 : result.intValue(); + return selectedUIStateValue; } /** * Clears out the selected UI that was last set in setSelectedUI. */ static void resetSelectedUI() { - AppContext.getAppContext().remove(SELECTED_UI_KEY); + selectedUI = null; + selectedUIStateValue = 0; } @@ -210,12 +188,8 @@ public class SynthLookAndFeel extends BasicLookAndFeel { */ public static void setStyleFactory(SynthStyleFactory cache) { // We assume the setter is called BEFORE the getter has been invoked - // for a particular AppContext. synchronized(SynthLookAndFeel.class) { - AppContext context = AppContext.getAppContext(); lastFactory = cache; - lastContext = context; - context.put(STYLE_FACTORY_KEY, cache); } } @@ -226,13 +200,6 @@ public class SynthLookAndFeel extends BasicLookAndFeel { */ public static SynthStyleFactory getStyleFactory() { synchronized(SynthLookAndFeel.class) { - AppContext context = AppContext.getAppContext(); - - if (lastContext == context) { - return lastFactory; - } - lastContext = context; - lastFactory = (SynthStyleFactory) context.get(STYLE_FACTORY_KEY); return lastFactory; } } diff --git a/test/jdk/javax/swing/plaf/synth/7143614/bug7143614.java b/test/jdk/javax/swing/plaf/synth/7143614/bug7143614.java deleted file mode 100644 index f1e1cbb94aa..00000000000 --- a/test/jdk/javax/swing/plaf/synth/7143614/bug7143614.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (c) 2012, 2015, 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 7143614 - * @summary Issues with Synth Look&Feel - * @author Pavel Porvatov - * @modules java.desktop/javax.swing.plaf.synth:open - * @modules java.desktop/sun.awt - */ - -import sun.awt.SunToolkit; - -import javax.swing.plaf.ComponentUI; -import javax.swing.plaf.basic.BasicButtonUI; -import javax.swing.plaf.synth.SynthConstants; -import javax.swing.plaf.synth.SynthLookAndFeel; -import java.lang.reflect.Method; - -public class bug7143614 { - private static Method setSelectedUIMethod; - - private static ComponentUI componentUI = new BasicButtonUI(); - - public static void main(String[] args) throws Exception { - setSelectedUIMethod = SynthLookAndFeel.class.getDeclaredMethod("setSelectedUI", ComponentUI.class, - boolean.class, boolean.class, boolean.class, boolean.class); - setSelectedUIMethod.setAccessible(true); - - setSelectedUIMethod.invoke(null, componentUI, true, true, true, true); - - validate(); - - Thread thread = new ThreadInAnotherAppContext(); - - thread.start(); - thread.join(); - - validate(); - - System.out.println("Test bug7143614 passed."); - } - - private static void validate() throws Exception { - Method getSelectedUIMethod = SynthLookAndFeel.class.getDeclaredMethod("getSelectedUI"); - - getSelectedUIMethod.setAccessible(true); - - Method getSelectedUIStateMethod = SynthLookAndFeel.class.getDeclaredMethod("getSelectedUIState"); - - getSelectedUIStateMethod.setAccessible(true); - - if (getSelectedUIMethod.invoke(null) != componentUI) { - throw new RuntimeException("getSelectedUI returns invalid value"); - } - if (((Integer) getSelectedUIStateMethod.invoke(null)).intValue() != - (SynthConstants.SELECTED | SynthConstants.FOCUSED)) { - throw new RuntimeException("getSelectedUIState returns invalid value"); - } - - } - - private static class ThreadInAnotherAppContext extends Thread { - public ThreadInAnotherAppContext() { - super(new ThreadGroup("7143614"), "ThreadInAnotherAppContext"); - } - - public void run() { - SunToolkit.createNewAppContext(); - - try { - setSelectedUIMethod.invoke(null, null, false, false, false, false); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - } -} diff --git a/test/jdk/javax/swing/plaf/synth/Test6660049.java b/test/jdk/javax/swing/plaf/synth/Test6660049.java deleted file mode 100644 index a7486eb86c8..00000000000 --- a/test/jdk/javax/swing/plaf/synth/Test6660049.java +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Copyright (c) 2009, 2016, 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 - * @key headful - * @bug 6660049 6849518 - * @summary Tests the Region initialization - * @author Sergey Malenkov - * @modules java.desktop/sun.awt - */ - -import sun.awt.SunToolkit; - -import javax.swing.JButton; -import javax.swing.JComponent; -import javax.swing.SwingUtilities; -import javax.swing.plaf.synth.Region; -import javax.swing.plaf.synth.SynthLookAndFeel; - -public class Test6660049 implements Runnable { - public static void main(String[] args) { - SwingUtilities.invokeLater(new Test6660049( - javax.swing.JButton.class, - javax.swing.JCheckBox.class, - javax.swing.JCheckBoxMenuItem.class, - javax.swing.JColorChooser.class, - javax.swing.JComboBox.class, - javax.swing.JDesktopPane.class, - javax.swing.JEditorPane.class, - javax.swing.JFileChooser.class, - javax.swing.JFormattedTextField.class, - javax.swing.JInternalFrame.class, - javax.swing.JLabel.class, - javax.swing.JList.class, - javax.swing.JMenu.class, - javax.swing.JMenuBar.class, - javax.swing.JMenuItem.class, - javax.swing.JOptionPane.class, - javax.swing.JPanel.class, - javax.swing.JPasswordField.class, - javax.swing.JPopupMenu.class, - javax.swing.JProgressBar.class, - javax.swing.JRadioButton.class, - javax.swing.JRadioButtonMenuItem.class, - javax.swing.JRootPane.class, - javax.swing.JScrollBar.class, - javax.swing.JScrollPane.class, - javax.swing.JSeparator.class, - javax.swing.JSlider.class, - javax.swing.JSpinner.class, - javax.swing.JSplitPane.class, - javax.swing.JTabbedPane.class, - javax.swing.JTable.class, - javax.swing.JTextArea.class, - javax.swing.JTextField.class, - javax.swing.JTextPane.class, - javax.swing.JToggleButton.class, - javax.swing.JToolBar.class, - javax.swing.JToolTip.class, - javax.swing.JTree.class, - javax.swing.JViewport.class, - javax.swing.table.JTableHeader.class)); - } - - private final Class[] types; - private final Region region; - - private Test6660049(Class... types) { - this.types = types; - run(); - - this.region = new Region("Button", "ButtonUI", true) { - @Override - public String getName() { - throw new Error("6660049: exploit is available"); - } - }; - } - - public void run() { - if (this.region != null) { - SunToolkit.createNewAppContext(); - } - for (Class type : this.types) { - Region region = getRegion(type); - if (region == null) { - throw new Error("6849518: region is not initialized"); - } - } - getRegion(JButton.class).getName(); - } - - private static Region getRegion(Class type) { - try { - return SynthLookAndFeel.getRegion(type.newInstance()); - } - catch (IllegalAccessException exception) { - throw new Error("unexpected exception", exception); - } - catch (InstantiationException exception) { - throw new Error("unexpected exception", exception); - } - } -} From 82bd3831b0f1e268ae76b31a803c86094add8e92 Mon Sep 17 00:00:00 2001 From: Hannes Greule Date: Mon, 26 Jan 2026 20:13:03 +0000 Subject: [PATCH 062/105] 8374538: Wrong specification of MethodHandles.constant(...) Reviewed-by: liach, jvernee --- .../share/classes/java/lang/invoke/MethodHandles.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandles.java b/src/java.base/share/classes/java/lang/invoke/MethodHandles.java index feb8aaaa1a9..7fde9d1dd89 100644 --- a/src/java.base/share/classes/java/lang/invoke/MethodHandles.java +++ b/src/java.base/share/classes/java/lang/invoke/MethodHandles.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, 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 @@ -4826,7 +4826,9 @@ assert((int)twice.invokeExact(21) == 42); * Before the method handle is returned, the passed-in value is converted to the requested type. * If the requested type is primitive, widening primitive conversions are attempted, * else reference conversions are attempted. - *

    The returned method handle is equivalent to {@code identity(type).bindTo(value)}. + *

    The returned method handle is equivalent to {@code identity(type).bindTo(value)}, + * for reference types. For all types it is equivalent to + * {@code insertArguments(identity(type), 0, value)}. * @param type the return type of the desired method handle * @param value the value to return * @return a method handle of the given return type and no arguments, which always returns the given value From 12570be64ae2114587e6de4ef79f79be961023b9 Mon Sep 17 00:00:00 2001 From: Damon Nguyen Date: Mon, 26 Jan 2026 21:13:01 +0000 Subject: [PATCH 063/105] 8376151: Test javax/swing/JFileChooser/4966171/bug4966171.java is failing with OOME Reviewed-by: prr, azvegint, aivanov --- test/jdk/javax/swing/JFileChooser/4966171/bug4966171.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/jdk/javax/swing/JFileChooser/4966171/bug4966171.java b/test/jdk/javax/swing/JFileChooser/4966171/bug4966171.java index f3b3ba684e6..27f26d570be 100644 --- a/test/jdk/javax/swing/JFileChooser/4966171/bug4966171.java +++ b/test/jdk/javax/swing/JFileChooser/4966171/bug4966171.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, 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 @@ -50,8 +50,8 @@ public final class bug4966171 { } private static void test() { - // Will run the test no more than 10 seconds per L&F - long endtime = System.nanoTime() + TimeUnit.SECONDS.toNanos(10); + // Will run the test no more than 5 seconds per L&F + long endtime = System.nanoTime() + TimeUnit.SECONDS.toNanos(5); while (System.nanoTime() < endtime) { try { var byteOut = new ByteArrayOutputStream(); From fdcc122a9db2f6fdeb014e9e731cd3992bb3d0f3 Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Tue, 27 Jan 2026 00:15:13 +0000 Subject: [PATCH 064/105] 8376422: Run compiler/corelibs/OptionalFold.java with tiered compilation Reviewed-by: dholmes --- test/hotspot/jtreg/compiler/corelibs/OptionalFold.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java b/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java index 0661a2e37e6..1f850aaf7cd 100644 --- a/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java +++ b/test/hotspot/jtreg/compiler/corelibs/OptionalFold.java @@ -41,7 +41,8 @@ import compiler.lib.ir_framework.TestFramework; public class OptionalFold { public static void main(String[] args) { - TestFramework.run(); + // Somehow fails with -XX:-TieredCompilation + TestFramework.runWithFlags("-XX:+TieredCompilation"); } // Ensure both present and empty values can fold From cba7d88ca427984ebb27a1634aab10a62c9eede1 Mon Sep 17 00:00:00 2001 From: Ioi Lam Date: Tue, 27 Jan 2026 03:16:43 +0000 Subject: [PATCH 065/105] 8374549: Extend MetaspaceClosure to cover non-MetaspaceObj types Reviewed-by: kvn, asmehra --- src/hotspot/share/cds/aotGrowableArray.cpp | 34 +++ src/hotspot/share/cds/aotGrowableArray.hpp | 76 +++++ .../share/cds/aotGrowableArray.inline.hpp | 37 +++ src/hotspot/share/cds/aotMapLogger.cpp | 64 +++- src/hotspot/share/cds/aotMapLogger.hpp | 12 +- src/hotspot/share/cds/aotMetaspace.cpp | 8 + src/hotspot/share/cds/archiveBuilder.cpp | 65 ++--- src/hotspot/share/cds/archiveBuilder.hpp | 10 +- src/hotspot/share/cds/cppVtables.cpp | 55 ++-- src/hotspot/share/cds/cppVtables.hpp | 5 +- src/hotspot/share/cds/dumpAllocStats.hpp | 30 +- src/hotspot/share/cds/heapShared.cpp | 6 +- .../share/classfile/classLoaderDataShared.cpp | 81 +++--- .../share/classfile/classLoaderDataShared.hpp | 8 +- src/hotspot/share/classfile/moduleEntry.cpp | 185 +++--------- src/hotspot/share/classfile/moduleEntry.hpp | 48 ++- src/hotspot/share/classfile/modules.cpp | 13 +- src/hotspot/share/classfile/modules.hpp | 3 +- src/hotspot/share/classfile/packageEntry.cpp | 107 ++----- src/hotspot/share/classfile/packageEntry.hpp | 28 +- src/hotspot/share/memory/allocation.cpp | 24 +- src/hotspot/share/memory/allocation.hpp | 4 +- src/hotspot/share/memory/metaspaceClosure.cpp | 16 +- src/hotspot/share/memory/metaspaceClosure.hpp | 274 +++++++++++++----- .../share/memory/metaspaceClosureType.hpp | 46 +++ src/hotspot/share/oops/array.hpp | 7 +- src/hotspot/share/oops/instanceKlass.cpp | 23 +- src/hotspot/share/runtime/sharedRuntime.hpp | 4 +- src/hotspot/share/utilities/growableArray.hpp | 8 +- .../gtest/utilities/test_metaspaceClosure.cpp | 100 ++++++- 30 files changed, 864 insertions(+), 517 deletions(-) create mode 100644 src/hotspot/share/cds/aotGrowableArray.cpp create mode 100644 src/hotspot/share/cds/aotGrowableArray.hpp create mode 100644 src/hotspot/share/cds/aotGrowableArray.inline.hpp create mode 100644 src/hotspot/share/memory/metaspaceClosureType.hpp diff --git a/src/hotspot/share/cds/aotGrowableArray.cpp b/src/hotspot/share/cds/aotGrowableArray.cpp new file mode 100644 index 00000000000..ec63e7aa57f --- /dev/null +++ b/src/hotspot/share/cds/aotGrowableArray.cpp @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +#include "cds/aotGrowableArray.hpp" +#include "cds/aotMetaspace.hpp" +#include "memory/allocation.inline.hpp" +#include "utilities/growableArray.hpp" + +void AOTGrowableArrayHelper::deallocate(void* mem) { + if (!AOTMetaspace::in_aot_cache(mem)) { + GrowableArrayCHeapAllocator::deallocate(mem); + } +} diff --git a/src/hotspot/share/cds/aotGrowableArray.hpp b/src/hotspot/share/cds/aotGrowableArray.hpp new file mode 100644 index 00000000000..0a0c137ed07 --- /dev/null +++ b/src/hotspot/share/cds/aotGrowableArray.hpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +#ifndef SHARE_AOT_AOTGROWABLEARRAY_HPP +#define SHARE_AOT_AOTGROWABLEARRAY_HPP + +#include +#include + +class AOTGrowableArrayHelper { +public: + static void deallocate(void* mem); +}; + +// An AOTGrowableArray provides the same functionality as a GrowableArray that +// uses the C heap allocator. In addition, AOTGrowableArray can be iterated with +// MetaspaceClosure. This type should be used for growable arrays that need to be +// stored in the AOT cache. See ModuleEntry::_reads for an example. +template +class AOTGrowableArray : public GrowableArrayWithAllocator> { + friend class VMStructs; + friend class GrowableArrayWithAllocator; + + static E* allocate(int max, MemTag mem_tag) { + return (E*)GrowableArrayCHeapAllocator::allocate(max, sizeof(E), mem_tag); + } + + E* allocate() { + return allocate(this->_capacity, mtClass); + } + + void deallocate(E* mem) { +#if INCLUDE_CDS + AOTGrowableArrayHelper::deallocate(mem); +#else + GrowableArrayCHeapAllocator::deallocate(mem); +#endif + } + +public: + AOTGrowableArray(int initial_capacity, MemTag mem_tag) : + GrowableArrayWithAllocator( + allocate(initial_capacity, mem_tag), + initial_capacity) {} + + AOTGrowableArray() : AOTGrowableArray(0, mtClassShared) {} + + // methods required by MetaspaceClosure + void metaspace_pointers_do(MetaspaceClosure* it); + int size_in_heapwords() const { return (int)heap_word_size(sizeof(*this)); } + MetaspaceClosureType type() const { return MetaspaceClosureType::GrowableArrayType; } + static bool is_read_only_by_default() { return false; } +}; + +#endif // SHARE_AOT_AOTGROWABLEARRAY_HPP diff --git a/src/hotspot/share/cds/aotGrowableArray.inline.hpp b/src/hotspot/share/cds/aotGrowableArray.inline.hpp new file mode 100644 index 00000000000..8c6e8cb6503 --- /dev/null +++ b/src/hotspot/share/cds/aotGrowableArray.inline.hpp @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +#ifndef SHARE_CDS_AOTGROWABLEARRAY_INLINE_HPP +#define SHARE_CDS_AOTGROWABLEARRAY_INLINE_HPP + +#include "cds/aotGrowableArray.hpp" + +#include "memory/metaspaceClosure.hpp" + +template +void AOTGrowableArray::metaspace_pointers_do(MetaspaceClosure* it) { + it->push_c_array(AOTGrowableArray::data_addr(), AOTGrowableArray::capacity()); +} + +#endif // SHARE_CDS_AOTGROWABLEARRAY_INLINE_HPP diff --git a/src/hotspot/share/cds/aotMapLogger.cpp b/src/hotspot/share/cds/aotMapLogger.cpp index a252eae4b84..5e4e0956824 100644 --- a/src/hotspot/share/cds/aotMapLogger.cpp +++ b/src/hotspot/share/cds/aotMapLogger.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -29,6 +29,8 @@ #include "cds/aotStreamedHeapWriter.hpp" #include "cds/cdsConfig.hpp" #include "cds/filemap.hpp" +#include "classfile/moduleEntry.hpp" +#include "classfile/packageEntry.hpp" #include "classfile/systemDictionaryShared.hpp" #include "classfile/vmClasses.hpp" #include "logging/log.hpp" @@ -141,7 +143,7 @@ public: info._buffered_addr = ref->obj(); info._requested_addr = ref->obj(); info._bytes = ref->size() * BytesPerWord; - info._type = ref->msotype(); + info._type = ref->type(); _objs.append(info); } @@ -214,7 +216,7 @@ void AOTMapLogger::dumptime_log_metaspace_region(const char* name, DumpRegion* r info._buffered_addr = src_info->buffered_addr(); info._requested_addr = info._buffered_addr + _buffer_to_requested_delta; info._bytes = src_info->size_in_bytes(); - info._type = src_info->msotype(); + info._type = src_info->type(); objs.append(info); } @@ -332,43 +334,52 @@ void AOTMapLogger::log_metaspace_objects_impl(address region_base, address regio address buffered_addr = info._buffered_addr; address requested_addr = info._requested_addr; int bytes = info._bytes; - MetaspaceObj::Type type = info._type; - const char* type_name = MetaspaceObj::type_name(type); + MetaspaceClosureType type = info._type; + const char* type_name = MetaspaceClosure::type_name(type); log_as_hex(last_obj_base, buffered_addr, last_obj_base + _buffer_to_requested_delta); switch (type) { - case MetaspaceObj::ClassType: + case MetaspaceClosureType::ClassType: log_klass((Klass*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::ConstantPoolType: + case MetaspaceClosureType::ConstantPoolType: log_constant_pool((ConstantPool*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::ConstantPoolCacheType: + case MetaspaceClosureType::ConstantPoolCacheType: log_constant_pool_cache((ConstantPoolCache*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::ConstMethodType: + case MetaspaceClosureType::ConstMethodType: log_const_method((ConstMethod*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::MethodType: + case MetaspaceClosureType::MethodType: log_method((Method*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::MethodCountersType: + case MetaspaceClosureType::MethodCountersType: log_method_counters((MethodCounters*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::MethodDataType: + case MetaspaceClosureType::MethodDataType: log_method_data((MethodData*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::SymbolType: + case MetaspaceClosureType::ModuleEntryType: + log_module_entry((ModuleEntry*)src, requested_addr, type_name, bytes, current); + break; + case MetaspaceClosureType::PackageEntryType: + log_package_entry((PackageEntry*)src, requested_addr, type_name, bytes, current); + break; + case MetaspaceClosureType::GrowableArrayType: + log_growable_array((GrowableArrayBase*)src, requested_addr, type_name, bytes, current); + break; + case MetaspaceClosureType::SymbolType: log_symbol((Symbol*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::KlassTrainingDataType: + case MetaspaceClosureType::KlassTrainingDataType: log_klass_training_data((KlassTrainingData*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::MethodTrainingDataType: + case MetaspaceClosureType::MethodTrainingDataType: log_method_training_data((MethodTrainingData*)src, requested_addr, type_name, bytes, current); break; - case MetaspaceObj::CompileTrainingDataType: + case MetaspaceClosureType::CompileTrainingDataType: log_compile_training_data((CompileTrainingData*)src, requested_addr, type_name, bytes, current); break; default: @@ -421,6 +432,27 @@ void AOTMapLogger::log_method_data(MethodData* md, address requested_addr, const log_debug(aot, map)(_LOG_PREFIX " %s", p2i(requested_addr), type_name, bytes, md->method()->external_name()); } +void AOTMapLogger::log_module_entry(ModuleEntry* mod, address requested_addr, const char* type_name, + int bytes, Thread* current) { + ResourceMark rm(current); + log_debug(aot, map)(_LOG_PREFIX " %s", p2i(requested_addr), type_name, bytes, + mod->name_as_C_string()); +} + +void AOTMapLogger::log_package_entry(PackageEntry* pkg, address requested_addr, const char* type_name, + int bytes, Thread* current) { + ResourceMark rm(current); + log_debug(aot, map)(_LOG_PREFIX " %s - %s", p2i(requested_addr), type_name, bytes, + pkg->module()->name_as_C_string(), pkg->name_as_C_string()); +} + +void AOTMapLogger::log_growable_array(GrowableArrayBase* arr, address requested_addr, const char* type_name, + int bytes, Thread* current) { + ResourceMark rm(current); + log_debug(aot, map)(_LOG_PREFIX " %d (%d)", p2i(requested_addr), type_name, bytes, + arr->length(), arr->capacity()); +} + void AOTMapLogger::log_klass(Klass* k, address requested_addr, const char* type_name, int bytes, Thread* current) { ResourceMark rm(current); diff --git a/src/hotspot/share/cds/aotMapLogger.hpp b/src/hotspot/share/cds/aotMapLogger.hpp index ba188514861..bf7ce0028b9 100644 --- a/src/hotspot/share/cds/aotMapLogger.hpp +++ b/src/hotspot/share/cds/aotMapLogger.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -28,6 +28,7 @@ #include "cds/archiveBuilder.hpp" #include "memory/allocation.hpp" #include "memory/allStatic.hpp" +#include "memory/metaspaceClosureType.hpp" #include "oops/oopsHierarchy.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/growableArray.hpp" @@ -37,9 +38,13 @@ class ArchiveStreamedHeapInfo; class CompileTrainingData; class DumpRegion; class FileMapInfo; +class GrowableArrayBase; class KlassTrainingData; +class MethodCounters; class MethodTrainingData; +class ModuleEntry; class outputStream; +class PackageEntry; // Write detailed info to a mapfile to analyze contents of the AOT cache/CDS archive. // -Xlog:aot+map* can be used both when creating an AOT cache, or when using an AOT cache. @@ -62,7 +67,7 @@ class AOTMapLogger : AllStatic { address _buffered_addr; address _requested_addr; int _bytes; - MetaspaceObj::Type _type; + MetaspaceClosureType _type; }; public: @@ -142,6 +147,9 @@ private: Thread* current); static void log_klass(Klass* k, address requested_addr, const char* type_name, int bytes, Thread* current); static void log_method(Method* m, address requested_addr, const char* type_name, int bytes, Thread* current); + static void log_module_entry(ModuleEntry* mod, address requested_addr, const char* type_name, int bytes, Thread* current); + static void log_package_entry(PackageEntry* pkg, address requested_addr, const char* type_name, int bytes, Thread* current); + static void log_growable_array(GrowableArrayBase* arr, address requested_addr, const char* type_name, int bytes, Thread* current); static void log_symbol(Symbol* s, address requested_addr, const char* type_name, int bytes, Thread* current); static void log_klass_training_data(KlassTrainingData* ktd, address requested_addr, const char* type_name, int bytes, Thread* current); static void log_method_training_data(MethodTrainingData* mtd, address requested_addr, const char* type_name, int bytes, Thread* current); diff --git a/src/hotspot/share/cds/aotMetaspace.cpp b/src/hotspot/share/cds/aotMetaspace.cpp index 79d789e0c70..683c897d855 100644 --- a/src/hotspot/share/cds/aotMetaspace.cpp +++ b/src/hotspot/share/cds/aotMetaspace.cpp @@ -698,6 +698,9 @@ public: Universe::metaspace_pointers_do(it); vmSymbols::metaspace_pointers_do(it); TrainingData::iterate_roots(it); + if (CDSConfig::is_dumping_full_module_graph()) { + ClassLoaderDataShared::iterate_roots(it); + } // The above code should find all the symbols that are referenced by the // archived classes. We just need to add the extra symbols which @@ -795,6 +798,10 @@ void VM_PopulateDumpSharedSpace::doit() { _builder.make_klasses_shareable(); AOTMetaspace::make_method_handle_intrinsics_shareable(); + if (CDSConfig::is_dumping_full_module_graph()) { + ClassLoaderDataShared::remove_unshareable_info(); + } + dump_java_heap_objects(); dump_shared_symbol_table(_builder.symbols()); @@ -1135,6 +1142,7 @@ void AOTMetaspace::dump_static_archive_impl(StaticArchiveBuilder& builder, TRAPS HeapShared::init_heap_writer(); if (CDSConfig::is_dumping_full_module_graph()) { ClassLoaderDataShared::ensure_module_entry_tables_exist(); + ClassLoaderDataShared::build_tables(CHECK); HeapShared::reset_archived_object_states(CHECK); } diff --git a/src/hotspot/share/cds/archiveBuilder.cpp b/src/hotspot/share/cds/archiveBuilder.cpp index 328bed1ccfb..9161980c4be 100644 --- a/src/hotspot/share/cds/archiveBuilder.cpp +++ b/src/hotspot/share/cds/archiveBuilder.cpp @@ -243,7 +243,7 @@ bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool re if (get_follow_mode(ref) != make_a_copy) { return false; } - if (ref->msotype() == MetaspaceObj::ClassType) { + if (ref->type() == MetaspaceClosureType::ClassType) { Klass* klass = (Klass*)ref->obj(); assert(klass->is_klass(), "must be"); if (!is_excluded(klass)) { @@ -252,7 +252,7 @@ bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool re assert(klass->is_instance_klass(), "must be"); } } - } else if (ref->msotype() == MetaspaceObj::SymbolType) { + } else if (ref->type() == MetaspaceClosureType::SymbolType) { // Make sure the symbol won't be GC'ed while we are dumping the archive. Symbol* sym = (Symbol*)ref->obj(); sym->increment_refcount(); @@ -271,11 +271,6 @@ void ArchiveBuilder::gather_klasses_and_symbols() { aot_log_info(aot)("Gathering classes and symbols ... "); GatherKlassesAndSymbols doit(this); iterate_roots(&doit); -#if INCLUDE_CDS_JAVA_HEAP - if (CDSConfig::is_dumping_full_module_graph()) { - ClassLoaderDataShared::iterate_symbols(&doit); - } -#endif doit.finish(); if (CDSConfig::is_dumping_static_archive()) { @@ -446,14 +441,14 @@ bool ArchiveBuilder::gather_one_source_obj(MetaspaceClosure::Ref* ref, bool read } #ifdef ASSERT - if (ref->msotype() == MetaspaceObj::MethodType) { + if (ref->type() == MetaspaceClosureType::MethodType) { Method* m = (Method*)ref->obj(); assert(!RegeneratedClasses::has_been_regenerated((address)m->method_holder()), "Should not archive methods in a class that has been regenerated"); } #endif - if (ref->msotype() == MetaspaceObj::MethodDataType) { + if (ref->type() == MetaspaceClosureType::MethodDataType) { MethodData* md = (MethodData*)ref->obj(); md->clean_method_data(false /* always_clean */); } @@ -554,16 +549,16 @@ ArchiveBuilder::FollowMode ArchiveBuilder::get_follow_mode(MetaspaceClosure::Ref if (CDSConfig::is_dumping_dynamic_archive() && AOTMetaspace::in_aot_cache(obj)) { // Don't dump existing shared metadata again. return point_to_it; - } else if (ref->msotype() == MetaspaceObj::MethodDataType || - ref->msotype() == MetaspaceObj::MethodCountersType || - ref->msotype() == MetaspaceObj::KlassTrainingDataType || - ref->msotype() == MetaspaceObj::MethodTrainingDataType || - ref->msotype() == MetaspaceObj::CompileTrainingDataType) { + } else if (ref->type() == MetaspaceClosureType::MethodDataType || + ref->type() == MetaspaceClosureType::MethodCountersType || + ref->type() == MetaspaceClosureType::KlassTrainingDataType || + ref->type() == MetaspaceClosureType::MethodTrainingDataType || + ref->type() == MetaspaceClosureType::CompileTrainingDataType) { return (TrainingData::need_data() || TrainingData::assembling_data()) ? make_a_copy : set_to_null; - } else if (ref->msotype() == MetaspaceObj::AdapterHandlerEntryType) { + } else if (ref->type() == MetaspaceClosureType::AdapterHandlerEntryType) { return CDSConfig::is_dumping_adapters() ? make_a_copy : set_to_null; } else { - if (ref->msotype() == MetaspaceObj::ClassType) { + if (ref->type() == MetaspaceClosureType::ClassType) { Klass* klass = (Klass*)ref->obj(); assert(klass->is_klass(), "must be"); if (RegeneratedClasses::has_been_regenerated(klass)) { @@ -620,15 +615,6 @@ void ArchiveBuilder::dump_rw_metadata() { ResourceMark rm; aot_log_info(aot)("Allocating RW objects ... "); make_shallow_copies(&_rw_region, &_rw_src_objs); - -#if INCLUDE_CDS_JAVA_HEAP - if (CDSConfig::is_dumping_full_module_graph()) { - // Archive the ModuleEntry's and PackageEntry's of the 3 built-in loaders - char* start = rw_region()->top(); - ClassLoaderDataShared::allocate_archived_tables(); - alloc_stats()->record_modules(rw_region()->top() - start, /*read_only*/false); - } -#endif } void ArchiveBuilder::dump_ro_metadata() { @@ -637,15 +623,6 @@ void ArchiveBuilder::dump_ro_metadata() { start_dump_region(&_ro_region); make_shallow_copies(&_ro_region, &_ro_src_objs); - -#if INCLUDE_CDS_JAVA_HEAP - if (CDSConfig::is_dumping_full_module_graph()) { - char* start = ro_region()->top(); - ClassLoaderDataShared::init_archived_tables(); - alloc_stats()->record_modules(ro_region()->top() - start, /*read_only*/true); - } -#endif - RegeneratedClasses::record_regenerated_objects(); } @@ -663,7 +640,7 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s size_t alignment = SharedSpaceObjectAlignment; // alignment for the dest pointer char* oldtop = dump_region->top(); - if (src_info->msotype() == MetaspaceObj::ClassType) { + if (src_info->type() == MetaspaceClosureType::ClassType) { // Allocate space for a pointer directly in front of the future InstanceKlass, so // we can do a quick lookup from InstanceKlass* -> RunTimeClassInfo* // without building another hashtable. See RunTimeClassInfo::get_for() @@ -679,7 +656,7 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s alignment = nth_bit(ArchiveBuilder::precomputed_narrow_klass_shift()); } #endif - } else if (src_info->msotype() == MetaspaceObj::SymbolType) { + } else if (src_info->type() == MetaspaceClosureType::SymbolType) { // Symbols may be allocated by using AllocateHeap, so their sizes // may be less than size_in_bytes() indicates. bytes = ((Symbol*)src)->byte_size(); @@ -689,7 +666,7 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s memcpy(dest, src, bytes); // Update the hash of buffered sorted symbols for static dump so that the symbols have deterministic contents - if (CDSConfig::is_dumping_static_archive() && (src_info->msotype() == MetaspaceObj::SymbolType)) { + if (CDSConfig::is_dumping_static_archive() && (src_info->type() == MetaspaceClosureType::SymbolType)) { Symbol* buffered_symbol = (Symbol*)dest; assert(((Symbol*)src)->is_permanent(), "archived symbols must be permanent"); buffered_symbol->update_identity_hash(); @@ -704,7 +681,7 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s } } - intptr_t* archived_vtable = CppVtables::get_archived_vtable(src_info->msotype(), (address)dest); + intptr_t* archived_vtable = CppVtables::get_archived_vtable(src_info->type(), (address)dest); if (archived_vtable != nullptr) { *(address*)dest = (address)archived_vtable; ArchivePtrMarker::mark_pointer((address*)dest); @@ -714,7 +691,7 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s src_info->set_buffered_addr((address)dest); char* newtop = dump_region->top(); - _alloc_stats.record(src_info->msotype(), int(newtop - oldtop), src_info->read_only()); + _alloc_stats.record(src_info->type(), int(newtop - oldtop), src_info->read_only()); DEBUG_ONLY(_alloc_stats.verify((int)dump_region->used(), src_info->read_only())); } @@ -997,15 +974,15 @@ void ArchiveBuilder::make_training_data_shareable() { return; } - if (info.msotype() == MetaspaceObj::KlassTrainingDataType || - info.msotype() == MetaspaceObj::MethodTrainingDataType || - info.msotype() == MetaspaceObj::CompileTrainingDataType) { + if (info.type() == MetaspaceClosureType::KlassTrainingDataType || + info.type() == MetaspaceClosureType::MethodTrainingDataType || + info.type() == MetaspaceClosureType::CompileTrainingDataType) { TrainingData* buffered_td = (TrainingData*)info.buffered_addr(); buffered_td->remove_unshareable_info(); - } else if (info.msotype() == MetaspaceObj::MethodDataType) { + } else if (info.type() == MetaspaceClosureType::MethodDataType) { MethodData* buffered_mdo = (MethodData*)info.buffered_addr(); buffered_mdo->remove_unshareable_info(); - } else if (info.msotype() == MetaspaceObj::MethodCountersType) { + } else if (info.type() == MetaspaceClosureType::MethodCountersType) { MethodCounters* buffered_mc = (MethodCounters*)info.buffered_addr(); buffered_mc->remove_unshareable_info(); } diff --git a/src/hotspot/share/cds/archiveBuilder.hpp b/src/hotspot/share/cds/archiveBuilder.hpp index 9a628439039..9de6c02edc5 100644 --- a/src/hotspot/share/cds/archiveBuilder.hpp +++ b/src/hotspot/share/cds/archiveBuilder.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -134,13 +134,13 @@ private: int _size_in_bytes; int _id; // Each object has a unique serial ID, starting from zero. The ID is assigned // when the object is added into _source_objs. - MetaspaceObj::Type _msotype; + MetaspaceClosureType _type; address _source_addr; // The source object to be copied. address _buffered_addr; // The copy of this object insider the buffer. public: SourceObjInfo(MetaspaceClosure::Ref* ref, bool read_only, FollowMode follow_mode) : _ptrmap_start(0), _ptrmap_end(0), _read_only(read_only), _has_embedded_pointer(false), _follow_mode(follow_mode), - _size_in_bytes(ref->size() * BytesPerWord), _id(0), _msotype(ref->msotype()), + _size_in_bytes(ref->size() * BytesPerWord), _id(0), _type(ref->type()), _source_addr(ref->obj()) { if (follow_mode == point_to_it) { _buffered_addr = ref->obj(); @@ -155,7 +155,7 @@ private: SourceObjInfo(address src, SourceObjInfo* renegerated_obj_info) : _ptrmap_start(0), _ptrmap_end(0), _read_only(false), _follow_mode(renegerated_obj_info->_follow_mode), - _size_in_bytes(0), _msotype(renegerated_obj_info->_msotype), + _size_in_bytes(0), _type(renegerated_obj_info->_type), _source_addr(src), _buffered_addr(renegerated_obj_info->_buffered_addr) {} bool should_copy() const { return _follow_mode == make_a_copy; } @@ -182,7 +182,7 @@ private: } return _buffered_addr; } - MetaspaceObj::Type msotype() const { return _msotype; } + MetaspaceClosureType type() const { return _type; } FollowMode follow_mode() const { return _follow_mode; } }; diff --git a/src/hotspot/share/cds/cppVtables.cpp b/src/hotspot/share/cds/cppVtables.cpp index f2862454286..da68fa70761 100644 --- a/src/hotspot/share/cds/cppVtables.cpp +++ b/src/hotspot/share/cds/cppVtables.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -22,12 +22,14 @@ * */ +#include "cds/aotGrowableArray.hpp" #include "cds/aotMetaspace.hpp" #include "cds/archiveBuilder.hpp" #include "cds/archiveUtils.hpp" #include "cds/cdsConfig.hpp" #include "cds/cppVtables.hpp" #include "logging/log.hpp" +#include "memory/resourceArea.hpp" #include "oops/instanceClassLoaderKlass.hpp" #include "oops/instanceMirrorKlass.hpp" #include "oops/instanceRefKlass.hpp" @@ -53,6 +55,19 @@ // + at run time: we clone the actual contents of the vtables from libjvm.so // into our own tables. + +#ifndef PRODUCT + +// AOTGrowableArray has a vtable only when in non-product builds (due to +// the virtual printing functions in AnyObj). + +using GrowableArray_ModuleEntry_ptr = AOTGrowableArray; + +#define DEBUG_CPP_VTABLE_TYPES_DO(f) \ + f(GrowableArray_ModuleEntry_ptr) \ + +#endif + // Currently, the archive contains ONLY the following types of objects that have C++ vtables. #define CPP_VTABLE_TYPES_DO(f) \ f(ConstantPool) \ @@ -68,7 +83,8 @@ f(TypeArrayKlass) \ f(KlassTrainingData) \ f(MethodTrainingData) \ - f(CompileTrainingData) + f(CompileTrainingData) \ + NOT_PRODUCT(DEBUG_CPP_VTABLE_TYPES_DO(f)) class CppVtableInfo { intptr_t _vtable_size; @@ -86,7 +102,7 @@ public: } }; -static inline intptr_t* vtable_of(const Metadata* m) { +static inline intptr_t* vtable_of(const void* m) { return *((intptr_t**)m); } @@ -116,6 +132,7 @@ CppVtableInfo* CppVtableCloner::allocate_and_initialize(const char* name) { template void CppVtableCloner::initialize(const char* name, CppVtableInfo* info) { + ResourceMark rm; T tmp; // Allocate temporary dummy metadata object to get to the original vtable. int n = info->vtable_size(); intptr_t* srcvtable = vtable_of(&tmp); @@ -268,7 +285,7 @@ void CppVtables::serialize(SerializeClosure* soc) { } } -intptr_t* CppVtables::get_archived_vtable(MetaspaceObj::Type msotype, address obj) { +intptr_t* CppVtables::get_archived_vtable(MetaspaceClosureType type, address obj) { if (!_orig_cpp_vtptrs_inited) { CPP_VTABLE_TYPES_DO(INIT_ORIG_CPP_VTPTRS); _orig_cpp_vtptrs_inited = true; @@ -276,19 +293,23 @@ intptr_t* CppVtables::get_archived_vtable(MetaspaceObj::Type msotype, address ob assert(CDSConfig::is_dumping_archive(), "sanity"); int kind = -1; - switch (msotype) { - case MetaspaceObj::SymbolType: - case MetaspaceObj::TypeArrayU1Type: - case MetaspaceObj::TypeArrayU2Type: - case MetaspaceObj::TypeArrayU4Type: - case MetaspaceObj::TypeArrayU8Type: - case MetaspaceObj::TypeArrayOtherType: - case MetaspaceObj::ConstMethodType: - case MetaspaceObj::ConstantPoolCacheType: - case MetaspaceObj::AnnotationsType: - case MetaspaceObj::RecordComponentType: - case MetaspaceObj::AdapterHandlerEntryType: - case MetaspaceObj::AdapterFingerPrintType: + switch (type) { + case MetaspaceClosureType::SymbolType: + case MetaspaceClosureType::TypeArrayU1Type: + case MetaspaceClosureType::TypeArrayU2Type: + case MetaspaceClosureType::TypeArrayU4Type: + case MetaspaceClosureType::TypeArrayU8Type: + case MetaspaceClosureType::TypeArrayOtherType: + case MetaspaceClosureType::CArrayType: + case MetaspaceClosureType::ConstMethodType: + case MetaspaceClosureType::ConstantPoolCacheType: + case MetaspaceClosureType::AnnotationsType: + case MetaspaceClosureType::ModuleEntryType: + case MetaspaceClosureType::PackageEntryType: + case MetaspaceClosureType::RecordComponentType: + case MetaspaceClosureType::AdapterHandlerEntryType: + case MetaspaceClosureType::AdapterFingerPrintType: + PRODUCT_ONLY(case MetaspaceClosureType::GrowableArrayType:) // These have no vtables. break; default: diff --git a/src/hotspot/share/cds/cppVtables.hpp b/src/hotspot/share/cds/cppVtables.hpp index b40ca036023..9e28ba020ee 100644 --- a/src/hotspot/share/cds/cppVtables.hpp +++ b/src/hotspot/share/cds/cppVtables.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -27,6 +27,7 @@ #include "memory/allocation.hpp" #include "memory/allStatic.hpp" +#include "memory/metaspaceClosureType.hpp" #include "utilities/globalDefinitions.hpp" class ArchiveBuilder; @@ -40,7 +41,7 @@ class CppVtables : AllStatic { public: static void dumptime_init(ArchiveBuilder* builder); static void zero_archived_vtables(); - static intptr_t* get_archived_vtable(MetaspaceObj::Type msotype, address obj); + static intptr_t* get_archived_vtable(MetaspaceClosureType type, address obj); static void serialize(SerializeClosure* sc); static bool is_valid_shared_method(const Method* m) NOT_CDS_RETURN_(false); static char* vtables_serialized_base() { return _vtables_serialized_base; } diff --git a/src/hotspot/share/cds/dumpAllocStats.hpp b/src/hotspot/share/cds/dumpAllocStats.hpp index 7d651320e6f..4553f0f6a01 100644 --- a/src/hotspot/share/cds/dumpAllocStats.hpp +++ b/src/hotspot/share/cds/dumpAllocStats.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -27,32 +27,34 @@ #include "classfile/compactHashtable.hpp" #include "memory/allocation.hpp" +#include "memory/metaspaceClosureType.hpp" // This is for dumping detailed statistics for the allocations // in the shared spaces. class DumpAllocStats : public StackObj { public: - // Here's poor man's enum inheritance -#define SHAREDSPACE_OBJ_TYPES_DO(f) \ - METASPACE_OBJ_TYPES_DO(f) \ +#define DUMPED_OBJ_TYPES_DO(f) \ + METASPACE_CLOSURE_TYPES_DO(f) \ f(SymbolHashentry) \ f(SymbolBucket) \ f(StringHashentry) \ f(StringBucket) \ - f(ModulesNatives) \ f(CppVTables) \ f(Other) +#define DUMPED_TYPE_DECLARE(name) name ## Type, +#define DUMPED_TYPE_NAME_CASE(name) case name ## Type: return #name; + enum Type { // Types are MetaspaceObj::ClassType, MetaspaceObj::SymbolType, etc - SHAREDSPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_DECLARE) + DUMPED_OBJ_TYPES_DO(DUMPED_TYPE_DECLARE) _number_of_types }; static const char* type_name(Type type) { switch(type) { - SHAREDSPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_NAME_CASE) + DUMPED_OBJ_TYPES_DO(DUMPED_TYPE_NAME_CASE) default: ShouldNotReachHere(); return nullptr; @@ -101,16 +103,12 @@ public: CompactHashtableStats* symbol_stats() { return &_symbol_stats; } CompactHashtableStats* string_stats() { return &_string_stats; } - void record(MetaspaceObj::Type type, int byte_size, bool read_only) { - assert(int(type) >= 0 && type < MetaspaceObj::_number_of_types, "sanity"); + void record(MetaspaceClosureType type, int byte_size, bool read_only) { + int t = (int)type; + assert(t >= 0 && t < (int)MetaspaceClosureType::_number_of_types, "sanity"); int which = (read_only) ? RO : RW; - _counts[which][type] ++; - _bytes [which][type] += byte_size; - } - - void record_modules(int byte_size, bool read_only) { - int which = (read_only) ? RO : RW; - _bytes [which][ModulesNativesType] += byte_size; + _counts[which][t] ++; + _bytes [which][t] += byte_size; } void record_other_type(int byte_size, bool read_only) { diff --git a/src/hotspot/share/cds/heapShared.cpp b/src/hotspot/share/cds/heapShared.cpp index fdc335f3799..89694c6780e 100644 --- a/src/hotspot/share/cds/heapShared.cpp +++ b/src/hotspot/share/cds/heapShared.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, 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 @@ -948,10 +948,6 @@ void HeapShared::archive_subgraphs() { true /* is_full_module_graph */); } } - - if (CDSConfig::is_dumping_full_module_graph()) { - Modules::verify_archived_modules(); - } } // diff --git a/src/hotspot/share/classfile/classLoaderDataShared.cpp b/src/hotspot/share/classfile/classLoaderDataShared.cpp index 7a7743edd03..d415fe64bac 100644 --- a/src/hotspot/share/classfile/classLoaderDataShared.cpp +++ b/src/hotspot/share/classfile/classLoaderDataShared.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -33,6 +33,7 @@ #include "classfile/packageEntry.hpp" #include "classfile/systemDictionary.hpp" #include "logging/log.hpp" +#include "memory/metaspaceClosure.hpp" #include "runtime/handles.inline.hpp" #include "runtime/safepoint.hpp" @@ -56,9 +57,9 @@ class ArchivedClassLoaderData { public: ArchivedClassLoaderData() : _packages(nullptr), _modules(nullptr), _unnamed_module(nullptr) {} - void iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure); - void allocate(ClassLoaderData* loader_data); - void init_archived_entries(ClassLoaderData* loader_data); + void iterate_roots(MetaspaceClosure* closure); + void build_tables(ClassLoaderData* loader_data, TRAPS); + void remove_unshareable_info(); ModuleEntry* unnamed_module() { return _unnamed_module; } @@ -80,17 +81,14 @@ static ModuleEntry* _archived_javabase_moduleEntry = nullptr; static int _platform_loader_root_index = -1; static int _system_loader_root_index = -1; -void ArchivedClassLoaderData::iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure) { +void ArchivedClassLoaderData::iterate_roots(MetaspaceClosure* it) { assert(CDSConfig::is_dumping_full_module_graph(), "must be"); - assert_valid(loader_data); - if (loader_data != nullptr) { - loader_data->packages()->iterate_symbols(closure); - loader_data->modules() ->iterate_symbols(closure); - loader_data->unnamed_module()->iterate_symbols(closure); - } + it->push(&_packages); + it->push(&_modules); + it->push(&_unnamed_module); } -void ArchivedClassLoaderData::allocate(ClassLoaderData* loader_data) { +void ArchivedClassLoaderData::build_tables(ClassLoaderData* loader_data, TRAPS) { assert(CDSConfig::is_dumping_full_module_graph(), "must be"); assert_valid(loader_data); if (loader_data != nullptr) { @@ -98,19 +96,28 @@ void ArchivedClassLoaderData::allocate(ClassLoaderData* loader_data) { // address of the Symbols, which may be relocated at runtime due to ASLR. // So we store the packages/modules in Arrays. At runtime, we create // the hashtables using these arrays. - _packages = loader_data->packages()->allocate_archived_entries(); - _modules = loader_data->modules() ->allocate_archived_entries(); - _unnamed_module = loader_data->unnamed_module()->allocate_archived_entry(); + _packages = loader_data->packages()->build_aot_table(loader_data, CHECK); + _modules = loader_data->modules()->build_aot_table(loader_data, CHECK); + _unnamed_module = loader_data->unnamed_module(); } } -void ArchivedClassLoaderData::init_archived_entries(ClassLoaderData* loader_data) { - assert(CDSConfig::is_dumping_full_module_graph(), "must be"); - assert_valid(loader_data); - if (loader_data != nullptr) { - loader_data->packages()->init_archived_entries(_packages); - loader_data->modules() ->init_archived_entries(_modules); - _unnamed_module->init_as_archived_entry(); +void ArchivedClassLoaderData::remove_unshareable_info() { + if (_packages != nullptr) { + _packages = ArchiveBuilder::current()->get_buffered_addr(_packages); + for (int i = 0; i < _packages->length(); i++) { + _packages->at(i)->remove_unshareable_info(); + } + } + if (_modules != nullptr) { + _modules = ArchiveBuilder::current()->get_buffered_addr(_modules); + for (int i = 0; i < _modules->length(); i++) { + _modules->at(i)->remove_unshareable_info(); + } + } + if (_unnamed_module != nullptr) { + _unnamed_module = ArchiveBuilder::current()->get_buffered_addr(_unnamed_module); + _unnamed_module->remove_unshareable_info(); } } @@ -153,7 +160,6 @@ void ArchivedClassLoaderData::clear_archived_oops() { // ------------------------------ void ClassLoaderDataShared::load_archived_platform_and_system_class_loaders() { -#if INCLUDE_CDS_JAVA_HEAP // The streaming object loader prefers loading the class loader related objects before // the CLD constructor which has a NoSafepointVerifier. if (!HeapShared::is_loading_streaming_mode()) { @@ -178,7 +184,6 @@ void ClassLoaderDataShared::load_archived_platform_and_system_class_loaders() { if (system_loader_module_entry != nullptr) { system_loader_module_entry->preload_archived_oops(); } -#endif } static ClassLoaderData* null_class_loader_data() { @@ -210,28 +215,27 @@ void ClassLoaderDataShared::ensure_module_entry_table_exists(oop class_loader) { assert(met != nullptr, "sanity"); } -void ClassLoaderDataShared::iterate_symbols(MetaspaceClosure* closure) { +void ClassLoaderDataShared::build_tables(TRAPS) { assert(CDSConfig::is_dumping_full_module_graph(), "must be"); - _archived_boot_loader_data.iterate_symbols (null_class_loader_data(), closure); - _archived_platform_loader_data.iterate_symbols(java_platform_loader_data_or_null(), closure); - _archived_system_loader_data.iterate_symbols (java_system_loader_data_or_null(), closure); + _archived_boot_loader_data.build_tables(null_class_loader_data(), CHECK); + _archived_platform_loader_data.build_tables(java_platform_loader_data_or_null(), CHECK); + _archived_system_loader_data.build_tables(java_system_loader_data_or_null(), CHECK); } -void ClassLoaderDataShared::allocate_archived_tables() { +void ClassLoaderDataShared::iterate_roots(MetaspaceClosure* it) { assert(CDSConfig::is_dumping_full_module_graph(), "must be"); - _archived_boot_loader_data.allocate (null_class_loader_data()); - _archived_platform_loader_data.allocate(java_platform_loader_data_or_null()); - _archived_system_loader_data.allocate (java_system_loader_data_or_null()); + _archived_boot_loader_data.iterate_roots(it); + _archived_platform_loader_data.iterate_roots(it); + _archived_system_loader_data.iterate_roots(it); } -void ClassLoaderDataShared::init_archived_tables() { +void ClassLoaderDataShared::remove_unshareable_info() { assert(CDSConfig::is_dumping_full_module_graph(), "must be"); + _archived_boot_loader_data.remove_unshareable_info(); + _archived_platform_loader_data.remove_unshareable_info(); + _archived_system_loader_data.remove_unshareable_info(); - _archived_boot_loader_data.init_archived_entries (null_class_loader_data()); - _archived_platform_loader_data.init_archived_entries(java_platform_loader_data_or_null()); - _archived_system_loader_data.init_archived_entries (java_system_loader_data_or_null()); - - _archived_javabase_moduleEntry = ModuleEntry::get_archived_entry(ModuleEntryTable::javabase_moduleEntry()); + _archived_javabase_moduleEntry = ArchiveBuilder::current()->get_buffered_addr(ModuleEntryTable::javabase_moduleEntry()); _platform_loader_root_index = HeapShared::append_root(SystemDictionary::java_platform_loader()); _system_loader_root_index = HeapShared::append_root(SystemDictionary::java_system_loader()); @@ -271,7 +275,6 @@ ModuleEntry* ClassLoaderDataShared::archived_unnamed_module(ClassLoaderData* loa return archived_module; } - void ClassLoaderDataShared::clear_archived_oops() { assert(!CDSConfig::is_using_full_module_graph(), "must be"); _archived_boot_loader_data.clear_archived_oops(); diff --git a/src/hotspot/share/classfile/classLoaderDataShared.hpp b/src/hotspot/share/classfile/classLoaderDataShared.hpp index 39d0a89418f..2cf37310e50 100644 --- a/src/hotspot/share/classfile/classLoaderDataShared.hpp +++ b/src/hotspot/share/classfile/classLoaderDataShared.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -40,11 +40,11 @@ class ClassLoaderDataShared : AllStatic { public: static void load_archived_platform_and_system_class_loaders() NOT_CDS_JAVA_HEAP_RETURN; static void restore_archived_modules_for_preloading_classes(JavaThread* current) NOT_CDS_JAVA_HEAP_RETURN; + static void build_tables(TRAPS) NOT_CDS_JAVA_HEAP_RETURN; + static void iterate_roots(MetaspaceClosure* closure) NOT_CDS_JAVA_HEAP_RETURN; + static void remove_unshareable_info() NOT_CDS_JAVA_HEAP_RETURN; #if INCLUDE_CDS_JAVA_HEAP static void ensure_module_entry_tables_exist(); - static void allocate_archived_tables(); - static void iterate_symbols(MetaspaceClosure* closure); - static void init_archived_tables(); static void serialize(SerializeClosure* f); static void clear_archived_oops(); static void restore_archived_entries_for_null_class_loader_data(); diff --git a/src/hotspot/share/classfile/moduleEntry.cpp b/src/hotspot/share/classfile/moduleEntry.cpp index 5fb3d6f2d13..b5b8aa4ef55 100644 --- a/src/hotspot/share/classfile/moduleEntry.cpp +++ b/src/hotspot/share/classfile/moduleEntry.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -23,6 +23,7 @@ */ #include "cds/aotClassLocation.hpp" +#include "cds/aotGrowableArray.inline.hpp" #include "cds/archiveBuilder.hpp" #include "cds/archiveUtils.hpp" #include "cds/cdsConfig.hpp" @@ -37,6 +38,7 @@ #include "jni.h" #include "logging/log.hpp" #include "logging/logStream.hpp" +#include "memory/metadataFactory.hpp" #include "memory/resourceArea.hpp" #include "memory/universe.hpp" #include "oops/oopHandle.inline.hpp" @@ -44,7 +46,6 @@ #include "runtime/handles.inline.hpp" #include "runtime/safepoint.hpp" #include "utilities/events.hpp" -#include "utilities/growableArray.hpp" #include "utilities/hashTable.hpp" #include "utilities/ostream.hpp" #include "utilities/quickSort.hpp" @@ -167,7 +168,7 @@ void ModuleEntry::add_read(ModuleEntry* m) { } else { if (reads() == nullptr) { // Lazily create a module's reads list - GrowableArray* new_reads = new (mtModule) GrowableArray(MODULE_READS_SIZE, mtModule); + AOTGrowableArray* new_reads = new (mtModule) AOTGrowableArray(MODULE_READS_SIZE, mtModule); set_reads(new_reads); } @@ -274,8 +275,7 @@ ModuleEntry::ModuleEntry(Handle module_handle, _has_default_read_edges(false), _must_walk_reads(false), _is_open(is_open), - _is_patched(false) - DEBUG_ONLY(COMMA _reads_is_archived(false)) { + _is_patched(false) { // Initialize fields specific to a ModuleEntry if (_name == nullptr) { @@ -394,7 +394,6 @@ ModuleEntryTable::~ModuleEntryTable() { ModuleEntryTableDeleter deleter; _table.unlink(&deleter); assert(_table.number_of_entries() == 0, "should have removed all entries"); - } void ModuleEntry::set_loader_data(ClassLoaderData* cld) { @@ -402,147 +401,51 @@ void ModuleEntry::set_loader_data(ClassLoaderData* cld) { _loader_data = cld; } +void ModuleEntry::metaspace_pointers_do(MetaspaceClosure* it) { + it->push(&_name); + it->push(&_reads); + it->push(&_version); + it->push(&_location); +} + #if INCLUDE_CDS_JAVA_HEAP -typedef HashTable< - const ModuleEntry*, - ModuleEntry*, - 557, // prime number - AnyObj::C_HEAP> ArchivedModuleEntries; -static ArchivedModuleEntries* _archive_modules_entries = nullptr; - -#ifndef PRODUCT -static int _num_archived_module_entries = 0; -static int _num_inited_module_entries = 0; -#endif - bool ModuleEntry::should_be_archived() const { return SystemDictionaryShared::is_builtin_loader(loader_data()); } -ModuleEntry* ModuleEntry::allocate_archived_entry() const { - precond(should_be_archived()); - precond(CDSConfig::is_dumping_full_module_graph()); - ModuleEntry* archived_entry = (ModuleEntry*)ArchiveBuilder::rw_region_alloc(sizeof(ModuleEntry)); - memcpy((void*)archived_entry, (void*)this, sizeof(ModuleEntry)); +void ModuleEntry::remove_unshareable_info() { + _archived_module_index = HeapShared::append_root(module_oop()); - archived_entry->_archived_module_index = HeapShared::append_root(module_oop()); - if (_archive_modules_entries == nullptr) { - _archive_modules_entries = new (mtClass)ArchivedModuleEntries(); - } - assert(_archive_modules_entries->get(this) == nullptr, "Each ModuleEntry must not be shared across ModuleEntryTables"); - _archive_modules_entries->put(this, archived_entry); - DEBUG_ONLY(_num_archived_module_entries++); - - if (CDSConfig::is_dumping_final_static_archive()) { - OopHandle null_handle; - archived_entry->_shared_pd = null_handle; - } else { - assert(archived_entry->shared_protection_domain() == nullptr, "never set during -Xshare:dump"); + if (_reads != nullptr) { + _reads->set_in_aot_cache(); } // Clear handles and restore at run time. Handles cannot be archived. + if (CDSConfig::is_dumping_final_static_archive()) { + OopHandle null_handle; + _shared_pd = null_handle; + } else { + assert(shared_protection_domain() == nullptr, "never set during -Xshare:dump"); + } + OopHandle null_handle; - archived_entry->_module_handle = null_handle; - - // For verify_archived_module_entries() - DEBUG_ONLY(_num_inited_module_entries++); - - if (log_is_enabled(Info, aot, module)) { - ResourceMark rm; - LogStream ls(Log(aot, module)::info()); - ls.print("Stored in archive: "); - archived_entry->print(&ls); - } - return archived_entry; -} - -bool ModuleEntry::has_been_archived() { - assert(!ArchiveBuilder::current()->is_in_buffer_space(this), "must be called on original ModuleEntry"); - return _archive_modules_entries->contains(this); -} - -ModuleEntry* ModuleEntry::get_archived_entry(ModuleEntry* orig_entry) { - ModuleEntry** ptr = _archive_modules_entries->get(orig_entry); - assert(ptr != nullptr && *ptr != nullptr, "must have been allocated"); - return *ptr; -} - -// This function is used to archive ModuleEntry::_reads and PackageEntry::_qualified_exports. -// GrowableArray cannot be directly archived, as it needs to be expandable at runtime. -// Write it out as an Array, and convert it back to GrowableArray at runtime. -Array* ModuleEntry::write_growable_array(GrowableArray* array) { - Array* archived_array = nullptr; - int length = (array == nullptr) ? 0 : array->length(); - if (length > 0) { - archived_array = ArchiveBuilder::new_ro_array(length); - for (int i = 0; i < length; i++) { - ModuleEntry* archived_entry = get_archived_entry(array->at(i)); - archived_array->at_put(i, archived_entry); - ArchivePtrMarker::mark_pointer((address*)archived_array->adr_at(i)); - } - } - - return archived_array; -} - -GrowableArray* ModuleEntry::restore_growable_array(Array* archived_array) { - GrowableArray* array = nullptr; - int length = (archived_array == nullptr) ? 0 : archived_array->length(); - if (length > 0) { - array = new (mtModule) GrowableArray(length, mtModule); - for (int i = 0; i < length; i++) { - ModuleEntry* archived_entry = archived_array->at(i); - array->append(archived_entry); - } - } - - return array; -} - -void ModuleEntry::iterate_symbols(MetaspaceClosure* closure) { - closure->push(&_name); - closure->push(&_version); - closure->push(&_location); -} - -void ModuleEntry::init_as_archived_entry() { - set_archived_reads(write_growable_array(reads())); + _module_handle = null_handle; _loader_data = nullptr; // re-init at runtime if (name() != nullptr) { - _shared_path_index = AOTClassLocationConfig::dumptime()->get_module_shared_path_index(_location); - _name = ArchiveBuilder::get_buffered_symbol(_name); - ArchivePtrMarker::mark_pointer((address*)&_name); + Symbol* src_location = ArchiveBuilder::current()->get_source_addr(_location); + _shared_path_index = AOTClassLocationConfig::dumptime()->get_module_shared_path_index(src_location); } else { // _shared_path_index is used only by SystemDictionary::is_shared_class_visible_impl() // for checking classes in named modules. _shared_path_index = -1; } - if (_version != nullptr) { - _version = ArchiveBuilder::get_buffered_symbol(_version); - } - if (_location != nullptr) { - _location = ArchiveBuilder::get_buffered_symbol(_location); - } JFR_ONLY(set_trace_id(0);) // re-init at runtime - - ArchivePtrMarker::mark_pointer((address*)&_reads); - ArchivePtrMarker::mark_pointer((address*)&_version); - ArchivePtrMarker::mark_pointer((address*)&_location); } -#ifndef PRODUCT -void ModuleEntry::verify_archived_module_entries() { - assert(_num_archived_module_entries == _num_inited_module_entries, - "%d ModuleEntries have been archived but %d of them have been properly initialized with archived java.lang.Module objects", - _num_archived_module_entries, _num_inited_module_entries); -} -#endif // PRODUCT - void ModuleEntry::load_from_archive(ClassLoaderData* loader_data) { assert(CDSConfig::is_using_archive(), "runtime only"); set_loader_data(loader_data); - set_reads(restore_growable_array(archived_reads())); JFR_ONLY(INIT_ID(this);) } @@ -581,38 +484,28 @@ static int compare_module_by_name(ModuleEntry* a, ModuleEntry* b) { return a->name()->fast_compare(b->name()); } -void ModuleEntryTable::iterate_symbols(MetaspaceClosure* closure) { - auto syms = [&] (const SymbolHandle& key, ModuleEntry*& m) { - m->iterate_symbols(closure); - }; - _table.iterate_all(syms); -} - -Array* ModuleEntryTable::allocate_archived_entries() { - Array* archived_modules = ArchiveBuilder::new_rw_array(_table.number_of_entries()); +Array* ModuleEntryTable::build_aot_table(ClassLoaderData* loader_data, TRAPS) { + Array* aot_table = + MetadataFactory::new_array(loader_data, _table.number_of_entries(), nullptr, CHECK_NULL); int n = 0; auto grab = [&] (const SymbolHandle& key, ModuleEntry*& m) { - archived_modules->at_put(n++, m); + m->pack_reads(); + aot_table->at_put(n++, m); + if (log_is_enabled(Info, aot, module)) { + ResourceMark rm; + LogStream ls(Log(aot, module)::info()); + ls.print("Stored in archive: "); + m->print(&ls); + } }; _table.iterate_all(grab); if (n > 1) { // Always allocate in the same order to produce deterministic archive. - QuickSort::sort(archived_modules->data(), n, compare_module_by_name); + QuickSort::sort(aot_table->data(), n, compare_module_by_name); } - for (int i = 0; i < n; i++) { - archived_modules->at_put(i, archived_modules->at(i)->allocate_archived_entry()); - ArchivePtrMarker::mark_pointer((address*)archived_modules->adr_at(i)); - } - return archived_modules; -} -void ModuleEntryTable::init_archived_entries(Array* archived_modules) { - assert(CDSConfig::is_dumping_full_module_graph(), "sanity"); - for (int i = 0; i < archived_modules->length(); i++) { - ModuleEntry* archived_entry = archived_modules->at(i); - archived_entry->init_as_archived_entry(); - } + return aot_table; } void ModuleEntryTable::load_archived_entries(ClassLoaderData* loader_data, diff --git a/src/hotspot/share/classfile/moduleEntry.hpp b/src/hotspot/share/classfile/moduleEntry.hpp index 2e1852c5369..1a0251a2c2a 100644 --- a/src/hotspot/share/classfile/moduleEntry.hpp +++ b/src/hotspot/share/classfile/moduleEntry.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -25,7 +25,9 @@ #ifndef SHARE_CLASSFILE_MODULEENTRY_HPP #define SHARE_CLASSFILE_MODULEENTRY_HPP +#include "cds/aotGrowableArray.hpp" #include "jni.h" +#include "memory/metaspaceClosureType.hpp" #include "oops/oopHandle.hpp" #include "oops/symbol.hpp" #include "oops/symbolHandle.hpp" @@ -68,11 +70,8 @@ private: // for shared classes from this module Symbol* _name; // name of this module ClassLoaderData* _loader_data; + AOTGrowableArray* _reads; // list of modules that are readable by this module - union { - GrowableArray* _reads; // list of modules that are readable by this module - Array* _archived_reads; // List of readable modules stored in the CDS archive - }; Symbol* _version; // module version number Symbol* _location; // module location CDS_ONLY(int _shared_path_index;) // >=0 if classes in this module are in CDS archive @@ -81,7 +80,6 @@ private: bool _must_walk_reads; // walk module's reads list at GC safepoints to purge out dead modules bool _is_open; // whether the packages in the module are all unqualifiedly exported bool _is_patched; // whether the module is patched via --patch-module - DEBUG_ONLY(bool _reads_is_archived); CDS_JAVA_HEAP_ONLY(int _archived_module_index;) JFR_ONLY(DEFINE_TRACE_ID_FIELD;) @@ -120,22 +118,18 @@ public: bool can_read(ModuleEntry* m) const; bool has_reads_list() const; - GrowableArray* reads() const { - assert(!_reads_is_archived, "sanity"); + AOTGrowableArray* reads() const { return _reads; } - void set_reads(GrowableArray* r) { + void set_reads(AOTGrowableArray* r) { _reads = r; - DEBUG_ONLY(_reads_is_archived = false); } - Array* archived_reads() const { - assert(_reads_is_archived, "sanity"); - return _archived_reads; - } - void set_archived_reads(Array* r) { - _archived_reads = r; - DEBUG_ONLY(_reads_is_archived = true); + void pack_reads() { + if (_reads != nullptr) { + _reads->shrink_to_fit(); + } } + void add_read(ModuleEntry* m); void set_read_walk_required(ClassLoaderData* m_loader_data); @@ -189,6 +183,13 @@ public: const char* name_as_C_string() const { return is_named() ? name()->as_C_string() : UNNAMED_MODULE; } + + // methods required by MetaspaceClosure + void metaspace_pointers_do(MetaspaceClosure* it); + int size_in_heapwords() const { return (int)heap_word_size(sizeof(ModuleEntry)); } + MetaspaceClosureType type() const { return MetaspaceClosureType::ModuleEntryType; } + static bool is_read_only_by_default() { return false; } + void print(outputStream* st = tty) const; void verify(); @@ -198,18 +199,11 @@ public: #if INCLUDE_CDS_JAVA_HEAP bool should_be_archived() const; - void iterate_symbols(MetaspaceClosure* closure); - ModuleEntry* allocate_archived_entry() const; - void init_as_archived_entry(); - static ModuleEntry* get_archived_entry(ModuleEntry* orig_entry); - bool has_been_archived(); - static Array* write_growable_array(GrowableArray* array); - static GrowableArray* restore_growable_array(Array* archived_array); + void remove_unshareable_info(); void load_from_archive(ClassLoaderData* loader_data); void preload_archived_oops(); void restore_archived_oops(ClassLoaderData* loader_data); void clear_archived_oops(); - static void verify_archived_module_entries() PRODUCT_RETURN; #endif }; @@ -275,9 +269,7 @@ public: void verify(); #if INCLUDE_CDS_JAVA_HEAP - void iterate_symbols(MetaspaceClosure* closure); - Array* allocate_archived_entries(); - void init_archived_entries(Array* archived_modules); + Array* build_aot_table(ClassLoaderData* loader_data, TRAPS); void load_archived_entries(ClassLoaderData* loader_data, Array* archived_modules); void restore_archived_oops(ClassLoaderData* loader_data, diff --git a/src/hotspot/share/classfile/modules.cpp b/src/hotspot/share/classfile/modules.cpp index baf2acfb78c..51d09d9c47f 100644 --- a/src/hotspot/share/classfile/modules.cpp +++ b/src/hotspot/share/classfile/modules.cpp @@ -1,5 +1,5 @@ /* -* Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. +* Copyright (c) 2016, 2026, 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 @@ -505,13 +505,10 @@ void Modules::check_archived_module_oop(oop orig_module_obj) { ClassLoaderData* loader_data = orig_module_ent->loader_data(); assert(loader_data->is_builtin_class_loader_data(), "must be"); - if (orig_module_ent->name() != nullptr) { - // For each named module, we archive both the java.lang.Module oop and the ModuleEntry. - assert(orig_module_ent->has_been_archived(), "sanity"); - } else { + precond(ArchiveBuilder::current()->has_been_archived(orig_module_ent)); + if (orig_module_ent->name() == nullptr) { // We always archive unnamed module oop for boot, platform, and system loaders. precond(orig_module_ent->should_be_archived()); - precond(orig_module_ent->has_been_archived()); if (loader_data->is_boot_class_loader_data()) { assert(!_seen_boot_unnamed_module, "only once"); @@ -529,10 +526,6 @@ void Modules::check_archived_module_oop(oop orig_module_obj) { } } -void Modules::verify_archived_modules() { - ModuleEntry::verify_archived_module_entries(); -} - class Modules::ArchivedProperty { const char* _prop; const bool _numbered; diff --git a/src/hotspot/share/classfile/modules.hpp b/src/hotspot/share/classfile/modules.hpp index 27a22c1017a..75857c8960c 100644 --- a/src/hotspot/share/classfile/modules.hpp +++ b/src/hotspot/share/classfile/modules.hpp @@ -1,5 +1,5 @@ /* -* Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. +* Copyright (c) 2016, 2026, 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 @@ -59,7 +59,6 @@ public: TRAPS) NOT_CDS_JAVA_HEAP_RETURN; static void init_archived_modules(JavaThread* current, Handle h_platform_loader, Handle h_system_loader) NOT_CDS_JAVA_HEAP_RETURN; - static void verify_archived_modules() NOT_CDS_JAVA_HEAP_RETURN; static void dump_archived_module_info() NOT_CDS_JAVA_HEAP_RETURN; static void serialize_archived_module_info(SerializeClosure* soc) NOT_CDS_JAVA_HEAP_RETURN; diff --git a/src/hotspot/share/classfile/packageEntry.cpp b/src/hotspot/share/classfile/packageEntry.cpp index ea2e6cd1def..3e61f2e3a3e 100644 --- a/src/hotspot/share/classfile/packageEntry.cpp +++ b/src/hotspot/share/classfile/packageEntry.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -22,6 +22,8 @@ * */ +#include "cds/aotGrowableArray.inline.hpp" +#include "cds/aotMetaspace.hpp" #include "cds/archiveBuilder.hpp" #include "cds/archiveUtils.hpp" #include "cds/cdsConfig.hpp" @@ -31,13 +33,13 @@ #include "classfile/vmSymbols.hpp" #include "logging/log.hpp" #include "logging/logStream.hpp" +#include "memory/metadataFactory.hpp" #include "memory/resourceArea.hpp" #include "oops/array.hpp" #include "oops/symbol.hpp" #include "runtime/handles.inline.hpp" #include "runtime/java.hpp" #include "utilities/events.hpp" -#include "utilities/growableArray.hpp" #include "utilities/hashTable.hpp" #include "utilities/ostream.hpp" #include "utilities/quickSort.hpp" @@ -51,7 +53,7 @@ PackageEntry::PackageEntry(Symbol* name, ModuleEntry* module) : _qualified_exports(nullptr), _defined_by_cds_in_class_path(0) { - // name can't be null + // name can't be null -- a class in the default package gets a PackageEntry of nullptr. _name->increment_refcount(); JFR_ONLY(INIT_ID(this);) @@ -81,7 +83,7 @@ void PackageEntry::add_qexport(ModuleEntry* m) { if (!has_qual_exports_list()) { // Lazily create a package's qualified exports list. // Initial size is small, do not anticipate export lists to be large. - _qualified_exports = new (mtModule) GrowableArray(QUAL_EXP_SIZE, mtModule); + _qualified_exports = new (mtModule) AOTGrowableArray(QUAL_EXP_SIZE, mtModule); } // Determine, based on this newly established export to module m, @@ -183,12 +185,24 @@ void PackageEntry::purge_qualified_exports() { } void PackageEntry::delete_qualified_exports() { - if (_qualified_exports != nullptr) { + if (_qualified_exports != nullptr && !AOTMetaspace::in_aot_cache(_qualified_exports)) { delete _qualified_exports; } _qualified_exports = nullptr; } +void PackageEntry::pack_qualified_exports() { + if (_qualified_exports != nullptr) { + _qualified_exports->shrink_to_fit(); + } +} + +void PackageEntry::metaspace_pointers_do(MetaspaceClosure* it) { + it->push(&_name); + it->push(&_module); + it->push(&_qualified_exports); +} + PackageEntryTable::PackageEntryTable() { } PackageEntryTable::~PackageEntryTable() { @@ -212,66 +226,19 @@ PackageEntryTable::~PackageEntryTable() { } #if INCLUDE_CDS_JAVA_HEAP -typedef HashTable< - const PackageEntry*, - PackageEntry*, - 557, // prime number - AnyObj::C_HEAP> ArchivedPackageEntries; -static ArchivedPackageEntries* _archived_packages_entries = nullptr; - bool PackageEntry::should_be_archived() const { return module()->should_be_archived(); } -PackageEntry* PackageEntry::allocate_archived_entry() const { - precond(should_be_archived()); - PackageEntry* archived_entry = (PackageEntry*)ArchiveBuilder::rw_region_alloc(sizeof(PackageEntry)); - memcpy((void*)archived_entry, (void*)this, sizeof(PackageEntry)); - - if (_archived_packages_entries == nullptr) { - _archived_packages_entries = new (mtClass)ArchivedPackageEntries(); +void PackageEntry::remove_unshareable_info() { + if (_qualified_exports != nullptr) { + _qualified_exports->set_in_aot_cache(); } - assert(_archived_packages_entries->get(this) == nullptr, "Each PackageEntry must not be shared across PackageEntryTables"); - _archived_packages_entries->put(this, archived_entry); - - return archived_entry; -} - -PackageEntry* PackageEntry::get_archived_entry(PackageEntry* orig_entry) { - PackageEntry** ptr = _archived_packages_entries->get(orig_entry); - if (ptr != nullptr) { - return *ptr; - } else { - return nullptr; - } -} - -void PackageEntry::iterate_symbols(MetaspaceClosure* closure) { - closure->push(&_name); -} - -void PackageEntry::init_as_archived_entry() { - Array* archived_qualified_exports = ModuleEntry::write_growable_array(_qualified_exports); - - _name = ArchiveBuilder::get_buffered_symbol(_name); - _module = ModuleEntry::get_archived_entry(_module); - _qualified_exports = (GrowableArray*)archived_qualified_exports; _defined_by_cds_in_class_path = 0; JFR_ONLY(set_trace_id(0);) // re-init at runtime - - ArchivePtrMarker::mark_pointer((address*)&_name); - ArchivePtrMarker::mark_pointer((address*)&_module); - ArchivePtrMarker::mark_pointer((address*)&_qualified_exports); - - LogStreamHandle(Info, aot, package) st; - if (st.is_enabled()) { - st.print("archived "); - print(&st); - } } void PackageEntry::load_from_archive() { - _qualified_exports = ModuleEntry::restore_growable_array((Array*)_qualified_exports); JFR_ONLY(INIT_ID(this);) } @@ -280,14 +247,7 @@ static int compare_package_by_name(PackageEntry* a, PackageEntry* b) { return a->name()->fast_compare(b->name()); } -void PackageEntryTable::iterate_symbols(MetaspaceClosure* closure) { - auto syms = [&] (const SymbolHandle& key, PackageEntry*& p) { - p->iterate_symbols(closure); - }; - _table.iterate_all(syms); -} - -Array* PackageEntryTable::allocate_archived_entries() { +Array* PackageEntryTable::build_aot_table(ClassLoaderData* loader_data, TRAPS) { // First count the packages in named modules int n = 0; auto count = [&] (const SymbolHandle& key, PackageEntry*& p) { @@ -297,12 +257,19 @@ Array* PackageEntryTable::allocate_archived_entries() { }; _table.iterate_all(count); - Array* archived_packages = ArchiveBuilder::new_rw_array(n); + Array* archived_packages = MetadataFactory::new_array(loader_data, n, nullptr, CHECK_NULL); // reset n n = 0; auto grab = [&] (const SymbolHandle& key, PackageEntry*& p) { if (p->should_be_archived()) { + p->pack_qualified_exports(); archived_packages->at_put(n++, p); + + LogStreamHandle(Info, aot, package) st; + if (st.is_enabled()) { + st.print("archived "); + p->print(&st); + } } }; _table.iterate_all(grab); @@ -311,18 +278,8 @@ Array* PackageEntryTable::allocate_archived_entries() { // Always allocate in the same order to produce deterministic archive. QuickSort::sort(archived_packages->data(), n, compare_package_by_name); } - for (int i = 0; i < n; i++) { - archived_packages->at_put(i, archived_packages->at(i)->allocate_archived_entry()); - ArchivePtrMarker::mark_pointer((address*)archived_packages->adr_at(i)); - } - return archived_packages; -} -void PackageEntryTable::init_archived_entries(Array* archived_packages) { - for (int i = 0; i < archived_packages->length(); i++) { - PackageEntry* archived_entry = archived_packages->at(i); - archived_entry->init_as_archived_entry(); - } + return archived_packages; } void PackageEntryTable::load_archived_entries(Array* archived_packages) { diff --git a/src/hotspot/share/classfile/packageEntry.hpp b/src/hotspot/share/classfile/packageEntry.hpp index 6abf89dc60f..7b174a92287 100644 --- a/src/hotspot/share/classfile/packageEntry.hpp +++ b/src/hotspot/share/classfile/packageEntry.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -25,7 +25,9 @@ #ifndef SHARE_CLASSFILE_PACKAGEENTRY_HPP #define SHARE_CLASSFILE_PACKAGEENTRY_HPP +#include "cds/aotGrowableArray.hpp" #include "classfile/moduleEntry.hpp" +#include "memory/metaspaceClosureType.hpp" #include "oops/symbol.hpp" #include "oops/symbolHandle.hpp" #include "runtime/atomicAccess.hpp" @@ -114,7 +116,7 @@ private: bool _must_walk_exports; // Contains list of modules this package is qualifiedly exported to. Access // to this list is protected by the Module_lock. - GrowableArray* _qualified_exports; + AOTGrowableArray* _qualified_exports; JFR_ONLY(DEFINE_TRACE_ID_FIELD;) // Initial size of a package entry's list of qualified exports. @@ -205,14 +207,24 @@ public: void purge_qualified_exports(); void delete_qualified_exports(); + void pack_qualified_exports(); // used by AOT + + // methods required by MetaspaceClosure + void metaspace_pointers_do(MetaspaceClosure* it); + int size_in_heapwords() const { return (int)heap_word_size(sizeof(PackageEntry)); } + MetaspaceClosureType type() const { return MetaspaceClosureType::PackageEntryType; } + static bool is_read_only_by_default() { return false; } + void print(outputStream* st = tty); + char* name_as_C_string() const { + assert(_name != nullptr, "name can't be null"); + return name()->as_C_string(); + } + #if INCLUDE_CDS_JAVA_HEAP bool should_be_archived() const; - void iterate_symbols(MetaspaceClosure* closure); - PackageEntry* allocate_archived_entry() const; - void init_as_archived_entry(); - static PackageEntry* get_archived_entry(PackageEntry* orig_entry); + void remove_unshareable_info(); void load_from_archive(); #endif @@ -271,9 +283,7 @@ public: void print(outputStream* st = tty); #if INCLUDE_CDS_JAVA_HEAP - void iterate_symbols(MetaspaceClosure* closure); - Array* allocate_archived_entries(); - void init_archived_entries(Array* archived_packages); + Array* build_aot_table(ClassLoaderData* loader_data, TRAPS); void load_archived_entries(Array* archived_packages); #endif }; diff --git a/src/hotspot/share/memory/allocation.cpp b/src/hotspot/share/memory/allocation.cpp index 9df91225d6f..2a109688ca6 100644 --- a/src/hotspot/share/memory/allocation.cpp +++ b/src/hotspot/share/memory/allocation.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -22,6 +22,7 @@ * */ +#include "cds/aotMetaspace.hpp" #include "memory/allocation.inline.hpp" #include "memory/arena.hpp" #include "memory/metaspace.hpp" @@ -161,12 +162,33 @@ void AnyObj::set_allocation_type(address res, allocation_type type) { } } +void AnyObj::set_in_aot_cache() { + _allocation_t[0] = 0; + _allocation_t[1] = 0; +} + +bool AnyObj::in_aot_cache() const { + if (AOTMetaspace::in_aot_cache(this)) { + precond(_allocation_t[0] == 0); + precond(_allocation_t[1] == 0); + return true; + } else { + return false; + } +} + AnyObj::allocation_type AnyObj::get_allocation_type() const { + if (in_aot_cache()) { + return STACK_OR_EMBEDDED; + } assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this, "lost resource object"); return (allocation_type)((~_allocation_t[0]) & allocation_mask); } bool AnyObj::is_type_set() const { + if (in_aot_cache()) { + return true; + } allocation_type type = (allocation_type)(_allocation_t[1] & allocation_mask); return get_allocation_type() == type && (_allocation_t[1] - type) == (uintptr_t)(&_allocation_t[1]); diff --git a/src/hotspot/share/memory/allocation.hpp b/src/hotspot/share/memory/allocation.hpp index 963ca04aadf..15b7750a363 100644 --- a/src/hotspot/share/memory/allocation.hpp +++ b/src/hotspot/share/memory/allocation.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -420,6 +420,7 @@ class AnyObj { public: enum allocation_type { STACK_OR_EMBEDDED = 0, RESOURCE_AREA, C_HEAP, ARENA, allocation_mask = 0x3 }; static void set_allocation_type(address res, allocation_type type) NOT_DEBUG_RETURN; + void set_in_aot_cache() NOT_DEBUG_RETURN; #ifdef ASSERT private: // When this object is allocated on stack the new() operator is not @@ -429,6 +430,7 @@ class AnyObj { uintptr_t _allocation_t[2]; bool is_type_set() const; void initialize_allocation_info(); + bool in_aot_cache() const; public: allocation_type get_allocation_type() const; bool allocated_on_stack_or_embedded() const { return get_allocation_type() == STACK_OR_EMBEDDED; } diff --git a/src/hotspot/share/memory/metaspaceClosure.cpp b/src/hotspot/share/memory/metaspaceClosure.cpp index f3c6e350034..0239eadf692 100644 --- a/src/hotspot/share/memory/metaspaceClosure.cpp +++ b/src/hotspot/share/memory/metaspaceClosure.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -22,7 +22,21 @@ * */ +#include "cds/aotGrowableArray.hpp" +#include "classfile/packageEntry.hpp" #include "memory/metaspaceClosure.hpp" +#include "oops/array.hpp" +#include "oops/instanceKlass.hpp" + +// Sanity checks +static_assert(!HAS_METASPACE_POINTERS_DO(int)); + +static_assert(HAS_METASPACE_POINTERS_DO(Array)); +static_assert(HAS_METASPACE_POINTERS_DO(Array)); +static_assert(HAS_METASPACE_POINTERS_DO(InstanceKlass)); +static_assert(HAS_METASPACE_POINTERS_DO(PackageEntry)); +static_assert(HAS_METASPACE_POINTERS_DO(AOTGrowableArray)); +static_assert(HAS_METASPACE_POINTERS_DO(AOTGrowableArray)); void MetaspaceClosure::push_impl(MetaspaceClosure::Ref* ref) { if (_enclosing_ref != nullptr) { diff --git a/src/hotspot/share/memory/metaspaceClosure.hpp b/src/hotspot/share/memory/metaspaceClosure.hpp index 329502d7a47..b6ba69d6f63 100644 --- a/src/hotspot/share/memory/metaspaceClosure.hpp +++ b/src/hotspot/share/memory/metaspaceClosure.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -25,9 +25,11 @@ #ifndef SHARE_MEMORY_METASPACECLOSURE_HPP #define SHARE_MEMORY_METASPACECLOSURE_HPP +#include "cds/aotGrowableArray.hpp" #include "cppstdlib/type_traits.hpp" #include "logging/log.hpp" #include "memory/allocation.hpp" +#include "memory/metaspaceClosureType.hpp" #include "metaprogramming/enableIf.hpp" #include "oops/array.hpp" #include "utilities/debug.hpp" @@ -36,41 +38,27 @@ #include "utilities/macros.hpp" #include "utilities/resizableHashTable.hpp" -// The metadata hierarchy is separate from the oop hierarchy - class MetaspaceObj; // no C++ vtable -//class Array; // no C++ vtable - class Annotations; // no C++ vtable - class ConstantPoolCache; // no C++ vtable - class ConstMethod; // no C++ vtable - class MethodCounters; // no C++ vtable - class Symbol; // no C++ vtable - class Metadata; // has C++ vtable (so do all subclasses) - class ConstantPool; - class MethodData; - class Method; - class Klass; - class InstanceKlass; - class InstanceMirrorKlass; - class InstanceClassLoaderKlass; - class InstanceRefKlass; - class ArrayKlass; - class ObjArrayKlass; - class TypeArrayKlass; +// This macro just check for the existence of a member with the name "metaspace_pointers_do". If the +// parameter list is not (MetaspaceClosure* it), you will get a compilation error. +#define HAS_METASPACE_POINTERS_DO(T) HasMetaspacePointersDo::value + +template +class HasMetaspacePointersDo { + template static void* test(decltype(&U::metaspace_pointers_do)); + template static int test(...); + using test_type = decltype(test(nullptr)); +public: + static constexpr bool value = std::is_pointer_v; +}; // class MetaspaceClosure -- // -// This class is used for iterating the objects in the HotSpot Metaspaces. It +// This class is used for iterating the class metadata objects. It // provides an API to walk all the reachable objects starting from a set of // root references (such as all Klass'es in the SystemDictionary). // -// Currently it is used for compacting the CDS archive by eliminate temporary -// objects allocated during archive creation time. See ArchiveBuilder for an example. -// -// To support MetaspaceClosure, each subclass of MetaspaceObj must provide -// a method of the type void metaspace_pointers_do(MetaspaceClosure*). This method -// should call MetaspaceClosure::push() on every pointer fields of this -// class that points to a MetaspaceObj. See Annotations::metaspace_pointers_do() -// for an example. +// Currently it is used to copy class metadata into the AOT cache. +// See ArchiveBuilder for an example. class MetaspaceClosure { public: enum Writability { @@ -79,16 +67,32 @@ public: _default }; +#define METASPACE_CLOSURE_TYPE_NAME_CASE(name) case MetaspaceClosureType::name ## Type: return #name; + + static const char* type_name(MetaspaceClosureType type) { + switch(type) { + METASPACE_CLOSURE_TYPES_DO(METASPACE_CLOSURE_TYPE_NAME_CASE) + default: + ShouldNotReachHere(); + return nullptr; + } + } + // class MetaspaceClosure::Ref -- // - // MetaspaceClosure can be viewed as a very simple type of copying garbage - // collector. For it to function properly, it requires each subclass of - // MetaspaceObj to provide two methods: + // For type X to be iterable by MetaspaceClosure, X (or one of X's supertypes) must have + // the following public functions: + // void metaspace_pointers_do(MetaspaceClosure* it); + // static bool is_read_only_by_default() { return true; } // - // size_t size(); -- to determine how much data to copy - // void metaspace_pointers_do(MetaspaceClosure*); -- to locate all the embedded pointers + // In addition, if X is not a subtype of MetaspaceObj, it must have the following function: + // MetaspaceClosureType type() const; + // int size_in_heapwords() const; // - // Calling these methods would be trivial if these two were virtual methods. + // Currently, the iterable types include all subtypes of MetsapceObj, as well + // as GrowableArray, ModuleEntry and PackageEntry. + // + // Calling these functions would be trivial if these were virtual functions. // However, to save space, MetaspaceObj has NO vtable. The vtable is introduced // only in the Metadata class. // @@ -97,7 +101,7 @@ public: // so that we can statically discover the type of a object. The use of Ref // depends on the fact that: // - // [1] We don't use polymorphic pointers for MetaspaceObj's that are not subclasses + // [1] We don't use polymorphic pointers to MetaspaceObj's that are not subclasses // of Metadata. I.e., we don't do this: // class Klass { // MetaspaceObj *_obj; @@ -130,8 +134,7 @@ public: virtual bool not_null() const = 0; virtual int size() const = 0; virtual void metaspace_pointers_do(MetaspaceClosure *it) const = 0; - virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const = 0; - virtual MetaspaceObj::Type msotype() const = 0; + virtual MetaspaceClosureType type() const = 0; virtual bool is_read_only_by_default() const = 0; virtual ~Ref() {} @@ -180,7 +183,26 @@ public: } private: - // MSORef -- iterate an instance of MetaspaceObj + template ::value)> + static int get_size(T* obj) { + return obj->size(); + } + + template ::value)> + static int get_size(T* obj) { + return obj->size_in_heapwords(); + } + + static MetaspaceClosureType as_type(MetaspaceClosureType t) { + return t; + } + + static MetaspaceClosureType as_type(MetaspaceObj::Type msotype) { + precond(msotype < MetaspaceObj::_number_of_types); + return (MetaspaceClosureType)msotype; + } + + // MSORef -- iterate an instance of T, where T::metaspace_pointers_do() exists. template class MSORef : public Ref { T** _mpp; T* dereference() const { @@ -196,18 +218,20 @@ private: virtual bool is_read_only_by_default() const { return T::is_read_only_by_default(); } virtual bool not_null() const { return dereference() != nullptr; } - virtual int size() const { return dereference()->size(); } - virtual MetaspaceObj::Type msotype() const { return dereference()->type(); } + virtual int size() const { return get_size(dereference()); } + virtual MetaspaceClosureType type() const { return as_type(dereference()->type()); } virtual void metaspace_pointers_do(MetaspaceClosure *it) const { dereference()->metaspace_pointers_do(it); } - virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { - ((T*)new_loc)->metaspace_pointers_do(it); - } }; - // abstract base class for MSOArrayRef, MSOPointerArrayRef and OtherArrayRef + //--------------------- + // Support for Array + //--------------------- + + // Abstract base class for MSOArrayRef, MSOPointerArrayRef and OtherArrayRef. + // These are used for iterating Array. template class ArrayRef : public Ref { Array** _mpp; protected: @@ -224,10 +248,10 @@ private: virtual bool is_read_only_by_default() const { return true; } virtual bool not_null() const { return dereference() != nullptr; } virtual int size() const { return dereference()->size(); } - virtual MetaspaceObj::Type msotype() const { return MetaspaceObj::array_type(sizeof(T)); } + virtual MetaspaceClosureType type() const { return as_type(MetaspaceObj::array_type(sizeof(T))); } }; - // OtherArrayRef -- iterate an instance of Array, where T is NOT a subtype of MetaspaceObj. + // OtherArrayRef -- iterate an instance of Array, where T does NOT have metaspace_pointer_do(). // T can be a primitive type, such as int, or a structure. However, we do not scan // the fields inside T, so you should not embed any pointers inside T. template class OtherArrayRef : public ArrayRef { @@ -238,13 +262,9 @@ private: Array* array = ArrayRef::dereference(); log_trace(aot)("Iter(OtherArray): %p [%d]", array, array->length()); } - virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { - Array* array = (Array*)new_loc; - log_trace(aot)("Iter(OtherArray): %p [%d]", array, array->length()); - } }; - // MSOArrayRef -- iterate an instance of Array, where T is a subtype of MetaspaceObj. + // MSOArrayRef -- iterate an instance of Array, where T has metaspace_pointer_do(). // We recursively call T::metaspace_pointers_do() for each element in this array. template class MSOArrayRef : public ArrayRef { public: @@ -253,9 +273,6 @@ private: virtual void metaspace_pointers_do(MetaspaceClosure *it) const { metaspace_pointers_do_at_impl(it, ArrayRef::dereference()); } - virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { - metaspace_pointers_do_at_impl(it, (Array*)new_loc); - } private: void metaspace_pointers_do_at_impl(MetaspaceClosure *it, Array* array) const { log_trace(aot)("Iter(MSOArray): %p [%d]", array, array->length()); @@ -266,7 +283,7 @@ private: } }; - // MSOPointerArrayRef -- iterate an instance of Array, where T is a subtype of MetaspaceObj. + // MSOPointerArrayRef -- iterate an instance of Array, where T has metaspace_pointer_do(). // We recursively call MetaspaceClosure::push() for each pointer in this array. template class MSOPointerArrayRef : public ArrayRef { public: @@ -275,9 +292,6 @@ private: virtual void metaspace_pointers_do(MetaspaceClosure *it) const { metaspace_pointers_do_at_impl(it, ArrayRef::dereference()); } - virtual void metaspace_pointers_do_at(MetaspaceClosure *it, address new_loc) const { - metaspace_pointers_do_at_impl(it, (Array*)new_loc); - } private: void metaspace_pointers_do_at_impl(MetaspaceClosure *it, Array* array) const { log_trace(aot)("Iter(MSOPointerArray): %p [%d]", array, array->length()); @@ -288,6 +302,102 @@ private: } }; + //-------------------------------- + // Support for AOTGrowableArray + //-------------------------------- + + // Abstract base class for MSOCArrayRef, MSOPointerCArrayRef and OtherCArrayRef. + // These are used for iterating the buffer held by AOTGrowableArray. + template class CArrayRef : public Ref { + T** _mpp; + int _num_elems; // Number of elements + + int byte_size() const { + return _num_elems * sizeof(T); + } + + protected: + // C pointer arrays don't support tagged pointers. + T* dereference() const { + return *_mpp; + } + virtual void** mpp() const { + return (void**)_mpp; + } + int num_elems() const { + return _num_elems; + } + public: + CArrayRef(T** mpp, int num_elems, Writability w) + : Ref(w), _mpp(mpp), _num_elems(num_elems) { + assert(is_aligned(byte_size(), BytesPerWord), "must be"); + } + + virtual bool is_read_only_by_default() const { return false; } + virtual bool not_null() const { return dereference() != nullptr; } + virtual int size() const { return (int)heap_word_size(byte_size()); } + virtual MetaspaceClosureType type() const { return MetaspaceClosureType::CArrayType; } + }; + + // OtherCArrayRef -- iterate a C array of type T, where T does NOT have metaspace_pointer_do(). + // T can be a primitive type, such as int, or a structure. However, we do not scan + // the fields inside T, so you should not embed any pointers inside T. + template class OtherCArrayRef : public CArrayRef { + public: + OtherCArrayRef(T** mpp, int num_elems, Writability w) : CArrayRef(mpp, num_elems, w) {} + + virtual void metaspace_pointers_do(MetaspaceClosure *it) const { + T* array = CArrayRef::dereference(); + log_trace(aot)("Iter(OtherCArray): %p [%d]", array, CArrayRef::num_elems()); + } + }; + + // MSOCArrayRef -- iterate a C array of type T, where T has metaspace_pointer_do(). + // We recursively call T::metaspace_pointers_do() for each element in this array. + // This is for supporting AOTGrowableArray. + // + // E.g., PackageEntry* _pkg_entry_pointers[2]; // a buffer that has 2 PackageEntry objects + // ... + // it->push(&_pkg_entry_pointers, 2); + // /* calls _pkg_entry_pointers[0].metaspace_pointers_do(it); */ + // /* calls _pkg_entry_pointers[1].metaspace_pointers_do(it); */ + template class MSOCArrayRef : public CArrayRef { + public: + MSOCArrayRef(T** mpp, int num_elems, Writability w) : CArrayRef(mpp, num_elems, w) {} + + virtual void metaspace_pointers_do(MetaspaceClosure *it) const { + T* array = CArrayRef::dereference(); + log_trace(aot)("Iter(MSOCArray): %p [%d]", array, CArrayRef::num_elems()); + for (int i = 0; i < CArrayRef::num_elems(); i++) { + T* elm = array + i; + elm->metaspace_pointers_do(it); + } + } + }; + + // MSOPointerCArrayRef -- iterate a C array of type T*, where T has metaspace_pointer_do(). + // We recursively call MetaspaceClosure::push() for each pointer in this array. + // This is for supporting AOTGrowableArray. + // + // E.g., PackageEntry** _pkg_entry_pointers[2]; // a buffer that has 2 PackageEntry pointers + // ... + // it->push(&_pkg_entry_pointers, 2); + // /* calls _pkg_entry_pointers[0]->metaspace_pointers_do(it); */ + // /* calls _pkg_entry_pointers[1]->metaspace_pointers_do(it); */ + template class MSOPointerCArrayRef : public CArrayRef { + public: + MSOPointerCArrayRef(T*** mpp, int num_elems, Writability w) : CArrayRef(mpp, num_elems, w) {} + + virtual void metaspace_pointers_do(MetaspaceClosure *it) const { + T** array = CArrayRef::dereference(); + log_trace(aot)("Iter(MSOPointerCArray): %p [%d]", array, CArrayRef::num_elems()); + for (int i = 0; i < CArrayRef::num_elems(); i++) { + T** mpp = array + i; + it->push(mpp); + } + } + }; + // Normally, chains of references like a->b->c->d are iterated recursively. However, // if recursion is too deep, we save the Refs in _pending_refs, and push them later in // MetaspaceClosure::finish(). This avoids overflowing the C stack. @@ -330,37 +440,61 @@ public: // Array*>* a4 = ...; it->push(&a4); => MSOPointerArrayRef // Array* a5 = ...; it->push(&a5); => MSOPointerArrayRef // - // Note that the following will fail to compile (to prevent you from adding new fields - // into the MetaspaceObj subtypes that cannot be properly copied by CDS): + // AOTGrowableArrays have a separate "C array" buffer, so they are scanned in two steps: // - // MemoryPool* p = ...; it->push(&p); => MemoryPool is not a subclass of MetaspaceObj - // Array* a6 = ...; it->push(&a6); => MemoryPool is not a subclass of MetaspaceObj - // Array* a7 = ...; it->push(&a7); => int is not a subclass of MetaspaceObj + // AOTGrowableArray* ga1 = ...; it->push(&ga1); => MSORef => OtherCArrayRef + // AOTGrowableArray* ga2 = ...; it->push(&ga2); => MSORef => MSOCArrayRef + // AOTGrowableArray* ga3 = ...; it->push(&ga3); => MSORef => MSOPointerCArrayRef + // + // Note that the following will fail to compile: + // + // MemoryPool* p = ...; it->push(&p); => MemoryPool doesn't have metaspace_pointers_do + // Array* a6 = ...; it->push(&a6); => MemoryPool doesn't have metaspace_pointers_do + // Array* a7 = ...; it->push(&a7); => int doesn't have metaspace_pointers_do + // --- Regular iterable objects template void push(T** mpp, Writability w = _default) { - static_assert(std::is_base_of::value, "Do not push pointers of arbitrary types"); + static_assert(HAS_METASPACE_POINTERS_DO(T), "Do not push pointers of arbitrary types"); push_with_ref>(mpp, w); } - template ::value)> + // --- Array + template void push(Array** mpp, Writability w = _default) { push_with_ref>(mpp, w); } - template ::value)> + template void push(Array** mpp, Writability w = _default) { push_with_ref>(mpp, w); } template void push(Array** mpp, Writability w = _default) { - static_assert(std::is_base_of::value, "Do not push Arrays of arbitrary pointer types"); + static_assert(HAS_METASPACE_POINTERS_DO(T), "Do not push Arrays of arbitrary pointer types"); push_with_ref>(mpp, w); } + + // --- The buffer of AOTGrowableArray + template + void push_c_array(T** mpp, int num_elems, Writability w = _default) { + push_impl(new OtherCArrayRef(mpp, num_elems, w)); + } + + template + void push_c_array(T** mpp, int num_elems, Writability w = _default) { + push_impl(new MSOCArrayRef(mpp, num_elems, w)); + } + + template + void push_c_array(T*** mpp, int num_elems, Writability w = _default) { + static_assert(HAS_METASPACE_POINTERS_DO(T), "Do not push C arrays of arbitrary pointer types"); + push_impl(new MSOPointerCArrayRef(mpp, num_elems, w)); + } }; -// This is a special MetaspaceClosure that visits each unique MetaspaceObj once. +// This is a special MetaspaceClosure that visits each unique object once. class UniqueMetaspaceClosure : public MetaspaceClosure { static const int INITIAL_TABLE_SIZE = 15889; static const int MAX_TABLE_SIZE = 1000000; diff --git a/src/hotspot/share/memory/metaspaceClosureType.hpp b/src/hotspot/share/memory/metaspaceClosureType.hpp new file mode 100644 index 00000000000..adf6805521b --- /dev/null +++ b/src/hotspot/share/memory/metaspaceClosureType.hpp @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +#ifndef SHARE_MEMORY_METASPACECLOSURETYPE_HPP +#define SHARE_MEMORY_METASPACECLOSURETYPE_HPP + +#include "memory/allocation.hpp" + +// MetaspaceClosure is able to iterate on MetaspaceObjs, plus the following classes +#define METASPACE_CLOSURE_TYPES_DO(f) \ + METASPACE_OBJ_TYPES_DO(f) \ + f(CArray) \ + f(GrowableArray) \ + f(ModuleEntry) \ + f(PackageEntry) \ + +#define METASPACE_CLOSURE_TYPE_DECLARE(name) name ## Type, + +enum class MetaspaceClosureType : int { + METASPACE_CLOSURE_TYPES_DO(METASPACE_CLOSURE_TYPE_DECLARE) + _number_of_types +}; + + +#endif // SHARE_MEMORY_METASPACECLOSURETYPE_HPP diff --git a/src/hotspot/share/oops/array.hpp b/src/hotspot/share/oops/array.hpp index 90dcc9dfeaf..82067e007ea 100644 --- a/src/hotspot/share/oops/array.hpp +++ b/src/hotspot/share/oops/array.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -33,6 +33,8 @@ // Array for metadata allocation +class MetaspaceClosure; + template class Array: public MetaspaceObj { friend class ArchiveBuilder; @@ -157,6 +159,9 @@ protected: st->print("Array(" PTR_FORMAT ")", p2i(this)); } + // This function does nothing. The iteration of the elements are done inside metaspaceClosure.hpp + void metaspace_pointers_do(MetaspaceClosure* it) {} + #ifndef PRODUCT void print(outputStream* st) { for (int i = 0; i< _length; i++) { diff --git a/src/hotspot/share/oops/instanceKlass.cpp b/src/hotspot/share/oops/instanceKlass.cpp index 56a80daed60..1963327fc78 100644 --- a/src/hotspot/share/oops/instanceKlass.cpp +++ b/src/hotspot/share/oops/instanceKlass.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -2693,6 +2693,10 @@ void InstanceKlass::metaspace_pointers_do(MetaspaceClosure* it) { it->push(&_nest_members); it->push(&_permitted_subclasses); it->push(&_record_components); + + if (CDSConfig::is_dumping_full_module_graph() && !defined_by_other_loaders()) { + it->push(&_package_entry); + } } #if INCLUDE_CDS @@ -2791,24 +2795,9 @@ void InstanceKlass::remove_java_mirror() { void InstanceKlass::init_shared_package_entry() { assert(CDSConfig::is_dumping_archive(), "must be"); -#if !INCLUDE_CDS_JAVA_HEAP - _package_entry = nullptr; -#else - if (CDSConfig::is_dumping_full_module_graph()) { - if (defined_by_other_loaders()) { - _package_entry = nullptr; - } else { - _package_entry = PackageEntry::get_archived_entry(_package_entry); - } - } else if (CDSConfig::is_dumping_dynamic_archive() && - CDSConfig::is_using_full_module_graph() && - AOTMetaspace::in_aot_cache(_package_entry)) { - // _package_entry is an archived package in the base archive. Leave it as is. - } else { + if (!CDSConfig::is_dumping_full_module_graph() || defined_by_other_loaders()) { _package_entry = nullptr; } - ArchivePtrMarker::mark_pointer((address**)&_package_entry); -#endif } void InstanceKlass::compute_has_loops_flag_for_methods() { diff --git a/src/hotspot/share/runtime/sharedRuntime.hpp b/src/hotspot/share/runtime/sharedRuntime.hpp index 140207e5d63..11bd39c839f 100644 --- a/src/hotspot/share/runtime/sharedRuntime.hpp +++ b/src/hotspot/share/runtime/sharedRuntime.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -30,7 +30,6 @@ #include "code/vmreg.hpp" #include "interpreter/linkResolver.hpp" #include "memory/allStatic.hpp" -#include "memory/metaspaceClosure.hpp" #include "memory/resourceArea.hpp" #include "runtime/safepointVerifiers.hpp" #include "runtime/stubInfo.hpp" @@ -38,6 +37,7 @@ class AdapterHandlerEntry; class AdapterFingerPrint; +class MetaspaceClosure; class vframeStream; // Runtime is the base class for various runtime interfaces diff --git a/src/hotspot/share/utilities/growableArray.hpp b/src/hotspot/share/utilities/growableArray.hpp index 1fef271c8c0..1823a2ba861 100644 --- a/src/hotspot/share/utilities/growableArray.hpp +++ b/src/hotspot/share/utilities/growableArray.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -116,6 +116,12 @@ protected: ~GrowableArrayView() {} +protected: + // Used by AOTGrowableArray for MetaspaceClosure support. + E** data_addr() { + return &_data; + } + public: bool operator==(const GrowableArrayView& rhs) const { if (_len != rhs._len) diff --git a/test/hotspot/gtest/utilities/test_metaspaceClosure.cpp b/test/hotspot/gtest/utilities/test_metaspaceClosure.cpp index b2acf45c470..c98b38b8c3c 100644 --- a/test/hotspot/gtest/utilities/test_metaspaceClosure.cpp +++ b/test/hotspot/gtest/utilities/test_metaspaceClosure.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -21,6 +21,7 @@ * questions. */ +#include "cds/aotGrowableArray.inline.hpp" #include "memory/allocation.hpp" #include "memory/metadataFactory.hpp" #include "memory/metaspaceClosure.hpp" @@ -58,7 +59,7 @@ public: class MyUniqueMetaspaceClosure : public MetaspaceClosure { static constexpr int SIZE = 10; - MyMetaData* _visited[SIZE]; + void* _visited[SIZE]; int _count; public: MyUniqueMetaspaceClosure() { @@ -71,11 +72,22 @@ public: virtual bool do_ref(Ref* ref, bool read_only) { MyMetaData* ptr = (MyMetaData*)ref->obj(); assert(_count < SIZE, "out of bounds"); - _visited[_count++] = ptr; + for (int i = 0; i < _count; i++) { + if (_visited[i] == (void*)ptr) { + // We have walked this before. + return false; + } + } + + // Found a new pointer. Let's walk it + _visited[_count++] = (void*)ptr; return true; // recurse } bool has_visited(MyMetaData* p) { + return has_visited((void*)p); + } + bool has_visited(void* p) { for (int i = 0; i < SIZE; i++) { if (_visited[i] == p) { return true; @@ -83,6 +95,9 @@ public: } return false; } + int visited_count() { + return _count; + } }; // iterate an Array @@ -104,7 +119,9 @@ TEST_VM(MetaspaceClosure, MSOPointerArrayRef) { MyUniqueMetaspaceClosure closure; closure.push(&array); + closure.finish(); + EXPECT_TRUE(closure.has_visited(array)) << "must be"; EXPECT_TRUE(closure.has_visited(&x)) << "must be"; EXPECT_TRUE(closure.has_visited(&y)) << "must be"; EXPECT_TRUE(closure.has_visited(&z)) << "must be"; @@ -130,8 +147,85 @@ TEST_VM(MetaspaceClosure, MSOArrayRef) { MyUniqueMetaspaceClosure closure; closure.push(&array); + closure.finish(); + EXPECT_TRUE(closure.has_visited(array)) << "must be"; EXPECT_TRUE(closure.has_visited(&x)) << "must be"; EXPECT_TRUE(closure.has_visited(&y)) << "must be"; EXPECT_TRUE(closure.has_visited(&z)) << "must be"; } + +// iterate an Array +TEST_VM(MetaspaceClosure, OtherArrayRef) { + JavaThread* THREAD = JavaThread::current(); + ClassLoaderData* cld = ClassLoaderData::the_null_class_loader_data(); + Array* array = MetadataFactory::new_array(cld, 4, THREAD); + + MyUniqueMetaspaceClosure closure; + closure.push(&array); + closure.finish(); + + EXPECT_TRUE(closure.has_visited(array)) << "must be"; +} + +// iterate an AOTGrowableArray +TEST_VM(MetaspaceClosure, GrowableArray_MSOPointer) { + AOTGrowableArray* array = new(mtClass) AOTGrowableArray(2, mtClass); + + MyMetaData x; + MyMetaData y; + MyMetaData z; + + array->push(&x); + array->push(&y); + y._a = &z; + + MyUniqueMetaspaceClosure closure; + closure.push(&array); + closure.finish(); + + EXPECT_TRUE(closure.has_visited(array)) << "must be"; + EXPECT_TRUE(closure.has_visited(&x)) << "must be"; + EXPECT_TRUE(closure.has_visited(&y)) << "must be"; + EXPECT_TRUE(closure.has_visited(&z)) << "must be"; +} + +// iterate an AOTGrowableArray +TEST_VM(MetaspaceClosure, GrowableArray_MSO) { + AOTGrowableArray* array = new(mtClass) AOTGrowableArray(4, mtClass); + + for (int i = 0; i < array->length(); i++) { + EXPECT_TRUE(array->at(i)._a == nullptr) << "should be initialized to null"; + EXPECT_TRUE(array->at(i)._b == nullptr) << "should be initialized to null"; + } + + MyMetaData x; + MyMetaData y; + MyMetaData z; + + z._a = &x; + z._b = &y; + y._a = &z; + array->push(z); + + MyUniqueMetaspaceClosure closure; + closure.push(&array); + closure.finish(); + + EXPECT_TRUE(closure.has_visited(array)) << "must be"; + EXPECT_TRUE(closure.has_visited(&x)) << "must be"; + EXPECT_TRUE(closure.has_visited(&y)) << "must be"; + EXPECT_TRUE(closure.has_visited(&z)) << "must be"; +} + +// iterate an AOTGrowableArray +TEST_VM(MetaspaceClosure, GrowableArray_jlong) { + AOTGrowableArray* array = new(mtClass) AOTGrowableArray(4, mtClass); + + MyUniqueMetaspaceClosure closure; + closure.push(&array); + closure.finish(); + + EXPECT_TRUE(closure.has_visited(array)) << "must be"; + EXPECT_TRUE(closure.visited_count() == 2) << "must visit buffer inside GrowableArray"; +} From 5c05d6f230e34cf409529d87b71f768a384ae4b4 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Tue, 27 Jan 2026 08:26:00 +0000 Subject: [PATCH 066/105] 8374686: ZGC: Convert zMarkTerminate to use Atomic Reviewed-by: stefank, kbarrett --- src/hotspot/share/gc/z/zMarkTerminate.hpp | 9 ++-- .../share/gc/z/zMarkTerminate.inline.hpp | 45 +++++++++---------- 2 files changed, 26 insertions(+), 28 deletions(-) diff --git a/src/hotspot/share/gc/z/zMarkTerminate.hpp b/src/hotspot/share/gc/z/zMarkTerminate.hpp index cff1f8e73fa..9def3e72120 100644 --- a/src/hotspot/share/gc/z/zMarkTerminate.hpp +++ b/src/hotspot/share/gc/z/zMarkTerminate.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -25,6 +25,7 @@ #define SHARE_GC_Z_ZMARKTERMINATE_HPP #include "gc/z/zLock.hpp" +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" class ZMarkStripeSet; @@ -32,9 +33,9 @@ class ZMarkStripeSet; class ZMarkTerminate { private: uint _nworkers; - volatile uint _nworking; - volatile uint _nawakening; - volatile bool _resurrected; + Atomic _nworking; + Atomic _nawakening; + Atomic _resurrected; ZConditionLock _lock; void maybe_reduce_stripes(ZMarkStripeSet* stripes, size_t used_nstripes); diff --git a/src/hotspot/share/gc/z/zMarkTerminate.inline.hpp b/src/hotspot/share/gc/z/zMarkTerminate.inline.hpp index 575044e3a39..84a545623bc 100644 --- a/src/hotspot/share/gc/z/zMarkTerminate.inline.hpp +++ b/src/hotspot/share/gc/z/zMarkTerminate.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -30,7 +30,6 @@ #include "gc/z/zLock.inline.hpp" #include "gc/z/zMarkStack.hpp" #include "logging/log.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/osThread.hpp" #include "runtime/thread.inline.hpp" @@ -42,24 +41,23 @@ inline ZMarkTerminate::ZMarkTerminate() _lock() {} inline void ZMarkTerminate::reset(uint nworkers) { - AtomicAccess::store(&_nworkers, nworkers); - AtomicAccess::store(&_nworking, nworkers); - _nawakening = 0; + _nworkers = nworkers; + _nworking.store_relaxed(nworkers); + _nawakening.store_relaxed(0u); } inline void ZMarkTerminate::leave() { SuspendibleThreadSetLeaver sts_leaver; ZLocker locker(&_lock); - AtomicAccess::store(&_nworking, _nworking - 1); - if (_nworking == 0) { + if (_nworking.sub_then_fetch(1u, memory_order_relaxed) == 0) { // Last thread leaving; notify waiters _lock.notify_all(); } } inline void ZMarkTerminate::maybe_reduce_stripes(ZMarkStripeSet* stripes, size_t used_nstripes) { - size_t nstripes = stripes->nstripes(); + const size_t nstripes = stripes->nstripes(); if (used_nstripes == nstripes && nstripes > 1u) { stripes->try_set_nstripes(nstripes, nstripes >> 1); } @@ -69,8 +67,7 @@ inline bool ZMarkTerminate::try_terminate(ZMarkStripeSet* stripes, size_t used_n SuspendibleThreadSetLeaver sts_leaver; ZLocker locker(&_lock); - AtomicAccess::store(&_nworking, _nworking - 1); - if (_nworking == 0) { + if (_nworking.sub_then_fetch(1u, memory_order_relaxed) == 0) { // Last thread entering termination: success _lock.notify_all(); return true; @@ -83,24 +80,24 @@ inline bool ZMarkTerminate::try_terminate(ZMarkStripeSet* stripes, size_t used_n // We either got notification about more work // or got a spurious wakeup; don't terminate - if (_nawakening > 0) { - AtomicAccess::store(&_nawakening, _nawakening - 1); + if (_nawakening.load_relaxed() > 0) { + _nawakening.sub_then_fetch(1u, memory_order_relaxed); } - if (_nworking == 0) { + if (_nworking.load_relaxed() == 0) { // We got notified all work is done; terminate return true; } - AtomicAccess::store(&_nworking, _nworking + 1); + _nworking.add_then_fetch(1u, memory_order_relaxed); return false; } inline void ZMarkTerminate::wake_up() { - uint nworking = AtomicAccess::load(&_nworking); - uint nawakening = AtomicAccess::load(&_nawakening); - if (nworking + nawakening == AtomicAccess::load(&_nworkers)) { + const uint nworking = _nworking.load_relaxed(); + const uint nawakening = _nawakening.load_relaxed(); + if (nworking + nawakening == _nworkers) { // Everyone is working or about to return; } @@ -111,24 +108,24 @@ inline void ZMarkTerminate::wake_up() { } ZLocker locker(&_lock); - if (_nworking + _nawakening != _nworkers) { + if (_nworking.load_relaxed() + _nawakening.load_relaxed() != _nworkers) { // Everyone is not working - AtomicAccess::store(&_nawakening, _nawakening + 1); + _nawakening.add_then_fetch(1u, memory_order_relaxed); _lock.notify(); } } inline bool ZMarkTerminate::saturated() const { - uint nworking = AtomicAccess::load(&_nworking); - uint nawakening = AtomicAccess::load(&_nawakening); + const uint nworking = _nworking.load_relaxed(); + const uint nawakening = _nawakening.load_relaxed(); - return nworking + nawakening == AtomicAccess::load(&_nworkers); + return nworking + nawakening == _nworkers; } inline void ZMarkTerminate::set_resurrected(bool value) { // Update resurrected if it changed if (resurrected() != value) { - AtomicAccess::store(&_resurrected, value); + _resurrected.store_relaxed(value); if (value) { log_debug(gc, marking)("Resurrection broke termination"); } else { @@ -138,7 +135,7 @@ inline void ZMarkTerminate::set_resurrected(bool value) { } inline bool ZMarkTerminate::resurrected() const { - return AtomicAccess::load(&_resurrected); + return _resurrected.load_relaxed(); } #endif // SHARE_GC_Z_ZMARKTERMINATE_INLINE_HPP From bd92c68ef0aa7615c62626eb6baf4496b0137cad Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Tue, 27 Jan 2026 08:36:41 +0000 Subject: [PATCH 067/105] 8374687: ZGC: Convert zNMethodTableIteration to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zNMethodTableIteration.cpp | 9 ++++----- src/hotspot/share/gc/z/zNMethodTableIteration.hpp | 9 +++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/hotspot/share/gc/z/zNMethodTableIteration.cpp b/src/hotspot/share/gc/z/zNMethodTableIteration.cpp index bdd4270ddac..423e98dd28b 100644 --- a/src/hotspot/share/gc/z/zNMethodTableIteration.cpp +++ b/src/hotspot/share/gc/z/zNMethodTableIteration.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -24,7 +24,6 @@ #include "gc/z/zNMethodTableEntry.hpp" #include "gc/z/zNMethodTableIteration.hpp" #include "memory/iterator.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/debug.hpp" #include "utilities/globalDefinitions.hpp" @@ -42,11 +41,11 @@ void ZNMethodTableIteration::nmethods_do_begin(ZNMethodTableEntry* table, size_t _table = table; _size = size; - _claimed = 0; + _claimed.store_relaxed(0u); } void ZNMethodTableIteration::nmethods_do_end() { - assert(_claimed >= _size, "Failed to claim all table entries"); + assert(_claimed.load_relaxed() >= _size, "Failed to claim all table entries"); // Finish iteration _table = nullptr; @@ -57,7 +56,7 @@ void ZNMethodTableIteration::nmethods_do(NMethodClosure* cl) { // Claim table partition. Each partition is currently sized to span // two cache lines. This number is just a guess, but seems to work well. const size_t partition_size = (ZCacheLineSize * 2) / sizeof(ZNMethodTableEntry); - const size_t partition_start = MIN2(AtomicAccess::fetch_then_add(&_claimed, partition_size), _size); + const size_t partition_start = MIN2(_claimed.fetch_then_add(partition_size), _size); const size_t partition_end = MIN2(partition_start + partition_size, _size); if (partition_start == partition_end) { // End of table diff --git a/src/hotspot/share/gc/z/zNMethodTableIteration.hpp b/src/hotspot/share/gc/z/zNMethodTableIteration.hpp index 064c3eafca0..12dc096491d 100644 --- a/src/hotspot/share/gc/z/zNMethodTableIteration.hpp +++ b/src/hotspot/share/gc/z/zNMethodTableIteration.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -25,15 +25,16 @@ #define SHARE_GC_Z_ZNMETHODTABLEITERATION_HPP #include "gc/z/zGlobals.hpp" +#include "runtime/atomic.hpp" class NMethodClosure; class ZNMethodTableEntry; class ZNMethodTableIteration { private: - ZNMethodTableEntry* _table; - size_t _size; - ZCACHE_ALIGNED volatile size_t _claimed; + ZNMethodTableEntry* _table; + size_t _size; + ZCACHE_ALIGNED Atomic _claimed; bool in_progress() const; From 6fda44172e955d4e1d181598a97902ed5b16c57b Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Tue, 27 Jan 2026 08:42:44 +0000 Subject: [PATCH 068/105] 8374690: ZGC: Convert zRelocate to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zRelocate.cpp | 26 +++++++++++++------------- src/hotspot/share/gc/z/zRelocate.hpp | 7 ++++--- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/src/hotspot/share/gc/z/zRelocate.cpp b/src/hotspot/share/gc/z/zRelocate.cpp index da07f67d859..d51cf5abbae 100644 --- a/src/hotspot/share/gc/z/zRelocate.cpp +++ b/src/hotspot/share/gc/z/zRelocate.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -64,31 +64,31 @@ ZRelocateQueue::ZRelocateQueue() _needs_attention(0) {} bool ZRelocateQueue::needs_attention() const { - return AtomicAccess::load(&_needs_attention) != 0; + return _needs_attention.load_relaxed() != 0; } void ZRelocateQueue::inc_needs_attention() { - const int needs_attention = AtomicAccess::add(&_needs_attention, 1); + const int needs_attention = _needs_attention.add_then_fetch(1); assert(needs_attention == 1 || needs_attention == 2, "Invalid state"); } void ZRelocateQueue::dec_needs_attention() { - const int needs_attention = AtomicAccess::sub(&_needs_attention, 1); + const int needs_attention = _needs_attention.sub_then_fetch(1); assert(needs_attention == 0 || needs_attention == 1, "Invalid state"); } void ZRelocateQueue::activate(uint nworkers) { - _is_active = true; + _is_active.store_relaxed(true); join(nworkers); } void ZRelocateQueue::deactivate() { - AtomicAccess::store(&_is_active, false); + _is_active.store_relaxed(false); clear(); } bool ZRelocateQueue::is_active() const { - return AtomicAccess::load(&_is_active); + return _is_active.load_relaxed(); } void ZRelocateQueue::join(uint nworkers) { @@ -453,7 +453,7 @@ static void retire_target_page(ZGeneration* generation, ZPage* page) { class ZRelocateSmallAllocator { private: ZGeneration* const _generation; - volatile size_t _in_place_count; + Atomic _in_place_count; public: ZRelocateSmallAllocator(ZGeneration* generation) @@ -463,7 +463,7 @@ public: ZPage* alloc_and_retire_target_page(ZForwarding* forwarding, ZPage* target) { ZPage* const page = alloc_page(forwarding); if (page == nullptr) { - AtomicAccess::inc(&_in_place_count); + _in_place_count.add_then_fetch(1u); } if (target != nullptr) { @@ -493,7 +493,7 @@ public: } size_t in_place_count() const { - return _in_place_count; + return _in_place_count.load_relaxed(); } }; @@ -503,7 +503,7 @@ private: ZConditionLock _lock; ZRelocationTargets* _shared_targets; bool _in_place; - volatile size_t _in_place_count; + Atomic _in_place_count; public: ZRelocateMediumAllocator(ZGeneration* generation, ZRelocationTargets* shared_targets) @@ -539,7 +539,7 @@ public: ZPage* const to_page = alloc_page(forwarding); _shared_targets->set(partition_id, to_age, to_page); if (to_page == nullptr) { - AtomicAccess::inc(&_in_place_count); + _in_place_count.add_then_fetch(1u); _in_place = true; } @@ -579,7 +579,7 @@ public: } size_t in_place_count() const { - return _in_place_count; + return _in_place_count.load_relaxed(); } }; diff --git a/src/hotspot/share/gc/z/zRelocate.hpp b/src/hotspot/share/gc/z/zRelocate.hpp index 038efba83eb..d25536e1bce 100644 --- a/src/hotspot/share/gc/z/zRelocate.hpp +++ b/src/hotspot/share/gc/z/zRelocate.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -28,6 +28,7 @@ #include "gc/z/zPageAge.hpp" #include "gc/z/zRelocationSet.hpp" #include "gc/z/zValue.hpp" +#include "runtime/atomic.hpp" class ZForwarding; class ZGeneration; @@ -42,8 +43,8 @@ private: uint _nworkers; uint _nsynchronized; bool _synchronize; - volatile bool _is_active; - volatile int _needs_attention; + Atomic _is_active; + Atomic _needs_attention; bool needs_attention() const; void inc_needs_attention(); From ee2deaded82e5fbd94aff7dd22cf2d5c57caa94e Mon Sep 17 00:00:00 2001 From: Varada M Date: Tue, 27 Jan 2026 10:01:02 +0000 Subject: [PATCH 069/105] 8371187: [BigEndian Platforms] Vector lane reversal error Reviewed-by: mdoerr, amitkumar --- .../jdk/incubator/vector/AbstractVector.java | 42 ++++++++++++++++++- .../jdk/incubator/vector/ByteVector.java | 8 ++++ .../jdk/incubator/vector/DoubleVector.java | 12 ++++++ .../jdk/incubator/vector/FloatVector.java | 12 ++++++ .../jdk/incubator/vector/IntVector.java | 12 ++++++ .../jdk/incubator/vector/LongVector.java | 12 ++++++ .../jdk/incubator/vector/ShortVector.java | 12 ++++++ 7 files changed, 109 insertions(+), 1 deletion(-) diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractVector.java index 350931cd443..09bb0607759 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractVector.java @@ -182,7 +182,44 @@ abstract class AbstractVector extends Vector { final AbstractVector asVectorRawTemplate(LaneType laneType) { // NOTE: This assumes that convert0('X') // respects REGISTER_ENDIAN order. - return convert0('X', vspecies().withLanes(laneType)); + return convert0('X', vspecies().withLanes(laneType)).swapIfNeeded(vspecies()); + } + + @ForceInline + protected static VectorShuffle normalizeSubLanesForSpecies(AbstractSpecies targetSpecies, int subLanesPerSrc) { + final int lanes = targetSpecies.laneCount(); + + if ((lanes % subLanesPerSrc) != 0) { + throw new IllegalArgumentException("laneCount " + lanes + " not divisible by subLanesPerSrc " + subLanesPerSrc); + } + + // Each group corresponds to one source lane. + // For each group, reverse the lanes inside that group. + final int groups = lanes / subLanesPerSrc; + int[] map = new int[lanes]; + for (int g = 0; g < groups; ++g) { + int base = g * subLanesPerSrc; + for (int j = 0; j < subLanesPerSrc; ++j) { + map[base + j] = base + (subLanesPerSrc - 1 - j); + } + } + return VectorShuffle.fromArray(targetSpecies, map, 0); + } + + @ForceInline + protected final int subLanesToSwap(AbstractSpecies srcSpecies) { + if (java.nio.ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN) { + return -1; + } + int sBytes = srcSpecies.elementSize(); + int tBytes = vspecies().elementSize(); + + // No lane reordering needed for same size or widening reinterprets + if (sBytes == tBytes || (sBytes % tBytes) != 0) { + return -1; + } + int subLanesPerSrc = sBytes / tBytes; + return subLanesPerSrc; } /*package-private*/ @@ -242,6 +279,9 @@ abstract class AbstractVector extends Vector { /*package-private*/ abstract AbstractVector maybeSwap(ByteOrder bo); + /*package-private*/ + abstract AbstractVector swapIfNeeded(AbstractSpecies srcSpecies); + /*package-private*/ @ForceInline VectorShuffle swapBytesShuffle() { diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java index 02e15d5f8dd..c071026a3b3 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java @@ -4101,6 +4101,14 @@ public abstract class ByteVector extends AbstractVector { return this; } + /*package-private*/ + @Override + @ForceInline + final + ByteVector swapIfNeeded(AbstractSpecies srcSpecies) { + return this; + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BYTE_INDEX_SCALE); static final long ARRAY_BASE = diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java index 08fda9c96e6..e280ca4150c 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java @@ -3612,6 +3612,18 @@ public abstract class DoubleVector extends AbstractVector { return this; } + @Override + @ForceInline + final + DoubleVector swapIfNeeded(AbstractSpecies srcSpecies) { + int subLanesPerSrc = subLanesToSwap(srcSpecies); + if (subLanesPerSrc < 0) { + return this; + } + VectorShuffle shuffle = normalizeSubLanesForSpecies(this.vspecies(), subLanesPerSrc); + return (DoubleVector) this.rearrange(shuffle); + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE); static final long ARRAY_BASE = diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java index 0f70a2b81c8..35a8f4a78cf 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java @@ -3562,6 +3562,18 @@ public abstract class FloatVector extends AbstractVector { return this; } + @Override + @ForceInline + final + FloatVector swapIfNeeded(AbstractSpecies srcSpecies) { + int subLanesPerSrc = subLanesToSwap(srcSpecies); + if (subLanesPerSrc < 0) { + return this; + } + VectorShuffle shuffle = normalizeSubLanesForSpecies(this.vspecies(), subLanesPerSrc); + return (FloatVector) this.rearrange(shuffle); + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_FLOAT_INDEX_SCALE); static final long ARRAY_BASE = diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java index 23e703dcada..f340aed4fce 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java @@ -3720,6 +3720,18 @@ public abstract class IntVector extends AbstractVector { return this; } + @Override + @ForceInline + final + IntVector swapIfNeeded(AbstractSpecies srcSpecies) { + int subLanesPerSrc = subLanesToSwap(srcSpecies); + if (subLanesPerSrc < 0) { + return this; + } + VectorShuffle shuffle = normalizeSubLanesForSpecies(this.vspecies(), subLanesPerSrc); + return (IntVector) this.rearrange(shuffle); + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_INT_INDEX_SCALE); static final long ARRAY_BASE = diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java index 58bfd4d7772..b842bdebdc4 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java @@ -3655,6 +3655,18 @@ public abstract class LongVector extends AbstractVector { return this; } + @Override + @ForceInline + final + LongVector swapIfNeeded(AbstractSpecies srcSpecies) { + int subLanesPerSrc = subLanesToSwap(srcSpecies); + if (subLanesPerSrc < 0) { + return this; + } + VectorShuffle shuffle = normalizeSubLanesForSpecies(this.vspecies(), subLanesPerSrc); + return (LongVector) this.rearrange(shuffle); + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_LONG_INDEX_SCALE); static final long ARRAY_BASE = diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java index 7ab7e7c4417..8b4c9bc5a77 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java @@ -4074,6 +4074,18 @@ public abstract class ShortVector extends AbstractVector { return this; } + @Override + @ForceInline + final + ShortVector swapIfNeeded(AbstractSpecies srcSpecies) { + int subLanesPerSrc = subLanesToSwap(srcSpecies); + if (subLanesPerSrc < 0) { + return this; + } + VectorShuffle shuffle = normalizeSubLanesForSpecies(this.vspecies(), subLanesPerSrc); + return (ShortVector) this.rearrange(shuffle); + } + static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_SHORT_INDEX_SCALE); static final long ARRAY_BASE = From e0445c09f7a967843a56634f72c7545446791e15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eirik=20Bj=C3=B8rsn=C3=B8s?= Date: Tue, 27 Jan 2026 10:25:58 +0000 Subject: [PATCH 070/105] 8376294: ZipFile.Source.Key should not hold on to its BasicFileAttributes instance Reviewed-by: jpai --- .../share/classes/java/util/zip/ZipFile.java | 23 +++++++++++-------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/src/java.base/share/classes/java/util/zip/ZipFile.java b/src/java.base/share/classes/java/util/zip/ZipFile.java index 7fa507980c2..bf43499e1f9 100644 --- a/src/java.base/share/classes/java/util/zip/ZipFile.java +++ b/src/java.base/share/classes/java/util/zip/ZipFile.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1995, 2026, 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 @@ -37,6 +37,7 @@ import java.nio.charset.Charset; import java.nio.file.InvalidPathException; import java.nio.file.attribute.BasicFileAttributes; import java.nio.file.Files; +import java.nio.file.attribute.FileTime; import java.util.*; import java.util.function.Consumer; import java.util.function.IntFunction; @@ -1444,11 +1445,13 @@ public class ZipFile implements ZipConstants, Closeable { * The unique combination of these components identifies a Source of a ZipFile. */ private static class Key { - private final BasicFileAttributes attrs; private final File file; + private final Object fileKey; + private final FileTime lastModifiedTime; // the Charset that was provided when constructing the ZipFile instance private final Charset charset; + /** * Constructs a {@code Key} to a {@code Source} of a {@code ZipFile} * @@ -1457,7 +1460,8 @@ public class ZipFile implements ZipConstants, Closeable { * @param charset the Charset that was provided when constructing the ZipFile instance */ public Key(File file, BasicFileAttributes attrs, Charset charset) { - this.attrs = attrs; + this.fileKey = attrs.fileKey(); + this.lastModifiedTime = attrs.lastModifiedTime(); this.file = file; this.charset = charset; } @@ -1465,10 +1469,9 @@ public class ZipFile implements ZipConstants, Closeable { @Override public int hashCode() { long t = charset.hashCode(); - t += attrs.lastModifiedTime().toMillis(); - Object fk = attrs.fileKey(); + t += lastModifiedTime.toMillis(); return Long.hashCode(t) + - (fk != null ? fk.hashCode() : file.hashCode()); + (fileKey != null ? fileKey.hashCode() : file.hashCode()); } @Override @@ -1477,12 +1480,12 @@ public class ZipFile implements ZipConstants, Closeable { if (!charset.equals(key.charset)) { return false; } - if (!attrs.lastModifiedTime().equals(key.attrs.lastModifiedTime())) { + if (!lastModifiedTime.equals(key.lastModifiedTime)) { return false; } - Object fk = attrs.fileKey(); - if (fk != null) { - return fk.equals(key.attrs.fileKey()); + + if (fileKey != null) { + return fileKey.equals(key.fileKey); } else { return file.equals(key.file); } From b1aea5520592e835e33762e349615fe616576103 Mon Sep 17 00:00:00 2001 From: Axel Boldt-Christmas Date: Tue, 27 Jan 2026 10:26:29 +0000 Subject: [PATCH 071/105] 8374695: ZGC: Convert zTLABUsage to use Atomic Reviewed-by: stefank, tschatzl --- src/hotspot/share/gc/z/zTLABUsage.cpp | 11 +++++------ src/hotspot/share/gc/z/zTLABUsage.hpp | 7 ++++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/hotspot/share/gc/z/zTLABUsage.cpp b/src/hotspot/share/gc/z/zTLABUsage.cpp index c2e3db6bedf..d3613cf8632 100644 --- a/src/hotspot/share/gc/z/zTLABUsage.cpp +++ b/src/hotspot/share/gc/z/zTLABUsage.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -23,24 +23,23 @@ #include "gc/z/zTLABUsage.hpp" #include "logging/log.hpp" -#include "runtime/atomicAccess.hpp" ZTLABUsage::ZTLABUsage() : _used(0), _used_history() {} void ZTLABUsage::increase_used(size_t size) { - AtomicAccess::add(&_used, size, memory_order_relaxed); + _used.add_then_fetch(size, memory_order_relaxed); } void ZTLABUsage::decrease_used(size_t size) { - precond(size <= _used); + precond(size <= _used.load_relaxed()); - AtomicAccess::sub(&_used, size, memory_order_relaxed); + _used.sub_then_fetch(size, memory_order_relaxed); } void ZTLABUsage::reset() { - const size_t used = AtomicAccess::xchg(&_used, (size_t) 0); + const size_t used = _used.exchange(0u); // Avoid updates when nothing has been allocated since the last YC if (used == 0) { diff --git a/src/hotspot/share/gc/z/zTLABUsage.hpp b/src/hotspot/share/gc/z/zTLABUsage.hpp index 3d1b084fe16..68c7620c26e 100644 --- a/src/hotspot/share/gc/z/zTLABUsage.hpp +++ b/src/hotspot/share/gc/z/zTLABUsage.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -24,6 +24,7 @@ #ifndef SHARE_GC_Z_ZTLABUSAGE_HPP #define SHARE_GC_Z_ZTLABUSAGE_HPP +#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/numberSeq.hpp" @@ -42,9 +43,9 @@ class ZTLABUsage { private: // Accounting TLAB used until the next GC cycle - volatile size_t _used; + Atomic _used; // Sequence of historic used values - TruncatedSeq _used_history; + TruncatedSeq _used_history; public: ZTLABUsage(); From 4ff5f3a8c0910e9ed9d77586bd692c469bdf3460 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eirik=20Bj=C3=B8rsn=C3=B8s?= Date: Tue, 27 Jan 2026 10:28:54 +0000 Subject: [PATCH 072/105] 8376271: ZipFile comment confusingly refers to "native" ZIP file implementation Reviewed-by: jpai --- src/java.base/share/classes/java/util/zip/ZipFile.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/java.base/share/classes/java/util/zip/ZipFile.java b/src/java.base/share/classes/java/util/zip/ZipFile.java index bf43499e1f9..a198c35c366 100644 --- a/src/java.base/share/classes/java/util/zip/ZipFile.java +++ b/src/java.base/share/classes/java/util/zip/ZipFile.java @@ -87,11 +87,11 @@ public class ZipFile implements ZipConstants, Closeable { private final ZipCoder zipCoder; private volatile boolean closeRequested; - // The "resource" used by this ZIP file that needs to be - // cleaned after use. + // An object holding state which needs to be cleaned after + // this ZipFile is closed or becomes unreachable: // a) the input streams that need to be closed // b) the list of cached Inflater objects - // c) the "native" source of this ZIP file. + // c) the Source object providing read access to the actual ZIP file private final @Stable CleanableResource res; private static final int STORED = ZipEntry.STORED; From 5990165d8257f39595b4c38f4e3e8d6ebb3393e8 Mon Sep 17 00:00:00 2001 From: Afshin Zafari Date: Tue, 27 Jan 2026 11:55:25 +0000 Subject: [PATCH 073/105] 8358957: [ubsan]: The assert in layout_helper_boolean_diffbit() in klass.hpp needs UB to fail Reviewed-by: dlong, jsjolen --- src/hotspot/share/oops/klass.hpp | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/src/hotspot/share/oops/klass.hpp b/src/hotspot/share/oops/klass.hpp index b6974762209..d59db9744cb 100644 --- a/src/hotspot/share/oops/klass.hpp +++ b/src/hotspot/share/oops/klass.hpp @@ -510,18 +510,20 @@ protected: return (BasicType) btvalue; } - // Want a pattern to quickly diff against layout header in register - // find something less clever! + // Return a value containing a single set bit that is in the bitset difference between the + // layout helpers for array-of-boolean and array-of-byte. static int layout_helper_boolean_diffbit() { - jint zlh = array_layout_helper(T_BOOLEAN); - jint blh = array_layout_helper(T_BYTE); - assert(zlh != blh, "array layout helpers must differ"); - int diffbit = 1; - while ((diffbit & (zlh ^ blh)) == 0 && (diffbit & zlh) == 0) { - diffbit <<= 1; - assert(diffbit != 0, "make sure T_BOOLEAN has a different bit than T_BYTE"); - } - return diffbit; + uint zlh = static_cast(array_layout_helper(T_BOOLEAN)); + uint blh = static_cast(array_layout_helper(T_BYTE)); + // get all the bits that are set in zlh and clear in blh + uint candidates = (zlh & ~blh); + assert(candidates != 0, "must be"); // must be some if there is a solution. + // Use well known bit hack to isolate the low bit of candidates. + uint result = candidates & (-candidates); + assert(is_power_of_2(result), "must be power of 2"); + assert((result & zlh) != 0, "must be set in alh of T_BOOLEAN"); + assert((result & blh) == 0, "must be clear in alh of T_BYTE"); + return static_cast(result); } static int layout_helper_log2_element_size(jint lh) { From 528bbe7919785c50dda583277f4146b25eb4d2a4 Mon Sep 17 00:00:00 2001 From: Casper Norrbin Date: Tue, 27 Jan 2026 12:33:43 +0000 Subject: [PATCH 074/105] 8376302: os::Machine::used_memory reports container used memory when running containerized Reviewed-by: eosterlund, sgehwolf --- src/hotspot/share/runtime/os.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/runtime/os.cpp b/src/hotspot/share/runtime/os.cpp index 1c06bf3c521..57971897400 100644 --- a/src/hotspot/share/runtime/os.cpp +++ b/src/hotspot/share/runtime/os.cpp @@ -2211,8 +2211,8 @@ bool os::used_memory(physical_memory_size_type& value) { bool os::Machine::used_memory(physical_memory_size_type& value) { physical_memory_size_type avail_mem = 0; // Return value ignored - defaulting to 0 on failure. - (void)os::available_memory(avail_mem); - physical_memory_size_type phys_mem = os::physical_memory(); + (void)os::Machine::available_memory(avail_mem); + physical_memory_size_type phys_mem = os::Machine::physical_memory(); value = phys_mem - avail_mem; return true; } From 40d1b642a43fbc5c6ad21417f2f9d62d99db0201 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Tue, 27 Jan 2026 12:51:20 +0000 Subject: [PATCH 075/105] 8376191: Remove AtomicAccess include from files that do not use it in gc/shared Reviewed-by: iwalulya, stefank --- src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp | 1 - src/hotspot/share/gc/shared/partialArrayState.cpp | 1 - src/hotspot/share/gc/shared/partialArrayTaskStepper.inline.hpp | 1 - src/hotspot/share/gc/shared/taskqueue.cpp | 1 - src/hotspot/share/gc/shared/taskqueue.inline.hpp | 1 - src/hotspot/share/gc/shared/workerThread.cpp | 1 - 6 files changed, 6 deletions(-) diff --git a/src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp b/src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp index 8e220e745e5..8341a3b20c4 100644 --- a/src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp +++ b/src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp @@ -31,7 +31,6 @@ #include "gc/shared/oopStorageSet.hpp" #include "memory/iterator.hpp" #include "oops/access.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/debug.hpp" template diff --git a/src/hotspot/share/gc/shared/partialArrayState.cpp b/src/hotspot/share/gc/shared/partialArrayState.cpp index 6f714d48a35..aadbc46b7c1 100644 --- a/src/hotspot/share/gc/shared/partialArrayState.cpp +++ b/src/hotspot/share/gc/shared/partialArrayState.cpp @@ -28,7 +28,6 @@ #include "memory/arena.hpp" #include "nmt/memTag.hpp" #include "oops/oopsHierarchy.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/orderAccess.hpp" #include "utilities/debug.hpp" #include "utilities/globalDefinitions.hpp" diff --git a/src/hotspot/share/gc/shared/partialArrayTaskStepper.inline.hpp b/src/hotspot/share/gc/shared/partialArrayTaskStepper.inline.hpp index aaa86e2de16..6946f7c69ff 100644 --- a/src/hotspot/share/gc/shared/partialArrayTaskStepper.inline.hpp +++ b/src/hotspot/share/gc/shared/partialArrayTaskStepper.inline.hpp @@ -28,7 +28,6 @@ #include "gc/shared/partialArrayTaskStepper.hpp" #include "gc/shared/partialArrayState.hpp" -#include "runtime/atomicAccess.hpp" #include "utilities/checkedCast.hpp" #include "utilities/debug.hpp" diff --git a/src/hotspot/share/gc/shared/taskqueue.cpp b/src/hotspot/share/gc/shared/taskqueue.cpp index f75dc4c2923..58af1793a48 100644 --- a/src/hotspot/share/gc/shared/taskqueue.cpp +++ b/src/hotspot/share/gc/shared/taskqueue.cpp @@ -25,7 +25,6 @@ #include "gc/shared/taskqueue.hpp" #include "logging/log.hpp" #include "oops/oop.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/javaThread.hpp" #include "runtime/os.hpp" #include "utilities/debug.hpp" diff --git a/src/hotspot/share/gc/shared/taskqueue.inline.hpp b/src/hotspot/share/gc/shared/taskqueue.inline.hpp index 55851495a5f..e77645f4fcf 100644 --- a/src/hotspot/share/gc/shared/taskqueue.inline.hpp +++ b/src/hotspot/share/gc/shared/taskqueue.inline.hpp @@ -32,7 +32,6 @@ #include "memory/allocation.inline.hpp" #include "memory/resourceArea.hpp" #include "oops/oop.inline.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/orderAccess.hpp" #include "utilities/debug.hpp" #include "utilities/ostream.hpp" diff --git a/src/hotspot/share/gc/shared/workerThread.cpp b/src/hotspot/share/gc/shared/workerThread.cpp index e4831d25d26..2f6f003608f 100644 --- a/src/hotspot/share/gc/shared/workerThread.cpp +++ b/src/hotspot/share/gc/shared/workerThread.cpp @@ -26,7 +26,6 @@ #include "gc/shared/workerThread.hpp" #include "logging/log.hpp" #include "memory/iterator.hpp" -#include "runtime/atomicAccess.hpp" #include "runtime/init.hpp" #include "runtime/java.hpp" #include "runtime/os.hpp" From 992a8ef46bc0a06c70fd5f4f307dbd20e402ed33 Mon Sep 17 00:00:00 2001 From: Daniel Gredler Date: Tue, 27 Jan 2026 13:20:26 +0000 Subject: [PATCH 076/105] 8376226: CharsetEncoder.canEncode(CharSequence) is much slower than necessary Reviewed-by: alanb, naoto --- .../nio/charset/Charset-X-Coder.java.template | 18 +- .../share/classes/sun/nio/cs/DoubleByte.java | 12 +- .../share/classes/sun/nio/cs/ISO_8859_1.java | 12 +- .../share/classes/sun/nio/cs/SingleByte.java | 12 +- .../share/classes/sun/nio/cs/US_ASCII.java | 12 +- .../bench/java/nio/CharsetCanEncode.java | 187 ++++++++++++++++++ 6 files changed, 245 insertions(+), 8 deletions(-) create mode 100644 test/micro/org/openjdk/bench/java/nio/CharsetCanEncode.java diff --git a/src/java.base/share/classes/java/nio/charset/Charset-X-Coder.java.template b/src/java.base/share/classes/java/nio/charset/Charset-X-Coder.java.template index e900c2eca0f..aca987ed678 100644 --- a/src/java.base/share/classes/java/nio/charset/Charset-X-Coder.java.template +++ b/src/java.base/share/classes/java/nio/charset/Charset-X-Coder.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -819,6 +819,12 @@ public abstract class Charset$Coder$ { */ public final $Otype$Buffer $code$($Itype$Buffer in) throws CharacterCodingException + { + return $code$(in, true); + } + + private $Otype$Buffer $code$($Itype$Buffer in, boolean throwOnError) + throws CharacterCodingException { int n = Math.min((int)(in.remaining() * average$ItypesPerOtype$()), ArraysSupport.SOFT_MAX_ARRAY_LENGTH); @@ -844,7 +850,11 @@ public abstract class Charset$Coder$ { out = o; continue; } - cr.throwException(); + if (throwOnError) { + cr.throwException(); + } else { + return null; + } } out.flip(); return out; @@ -938,7 +948,8 @@ public abstract class Charset$Coder$ { try { onMalformedInput(CodingErrorAction.REPORT); onUnmappableCharacter(CodingErrorAction.REPORT); - encode(cb); + ByteBuffer bb = encode(cb, false); + return bb != null; } catch (CharacterCodingException x) { return false; } finally { @@ -946,7 +957,6 @@ public abstract class Charset$Coder$ { onUnmappableCharacter(ua); reset(); } - return true; } /** diff --git a/src/java.base/share/classes/sun/nio/cs/DoubleByte.java b/src/java.base/share/classes/sun/nio/cs/DoubleByte.java index 2a4dbdc95ed..0aaae14bbf9 100644 --- a/src/java.base/share/classes/sun/nio/cs/DoubleByte.java +++ b/src/java.base/share/classes/sun/nio/cs/DoubleByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2026, 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 @@ -583,6 +583,16 @@ public class DoubleByte { return encodeChar(c) != UNMAPPABLE_ENCODING; } + public boolean canEncode(CharSequence cs) { + int length = cs.length(); + for (int i = 0; i < length; i++) { + if (!canEncode(cs.charAt(i))) { + return false; + } + } + return true; + } + protected Surrogate.Parser sgp() { if (sgp == null) sgp = new Surrogate.Parser(); diff --git a/src/java.base/share/classes/sun/nio/cs/ISO_8859_1.java b/src/java.base/share/classes/sun/nio/cs/ISO_8859_1.java index 39215bfa93d..9240ac3f380 100644 --- a/src/java.base/share/classes/sun/nio/cs/ISO_8859_1.java +++ b/src/java.base/share/classes/sun/nio/cs/ISO_8859_1.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -136,6 +136,16 @@ public class ISO_8859_1 return c <= '\u00FF'; } + public boolean canEncode(CharSequence cs) { + int length = cs.length(); + for (int i = 0; i < length; i++) { + if (!canEncode(cs.charAt(i))) { + return false; + } + } + return true; + } + public boolean isLegalReplacement(byte[] repl) { return true; // we accept any byte value } diff --git a/src/java.base/share/classes/sun/nio/cs/SingleByte.java b/src/java.base/share/classes/sun/nio/cs/SingleByte.java index 59887b944d3..d4127b7c043 100644 --- a/src/java.base/share/classes/sun/nio/cs/SingleByte.java +++ b/src/java.base/share/classes/sun/nio/cs/SingleByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, 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 @@ -201,6 +201,16 @@ public class SingleByte return encode(c) != UNMAPPABLE_ENCODING; } + public boolean canEncode(CharSequence cs) { + int length = cs.length(); + for (int i = 0; i < length; i++) { + if (!canEncode(cs.charAt(i))) { + return false; + } + } + return true; + } + public boolean isLegalReplacement(byte[] repl) { return ((repl.length == 1 && repl[0] == (byte)'?') || super.isLegalReplacement(repl)); diff --git a/src/java.base/share/classes/sun/nio/cs/US_ASCII.java b/src/java.base/share/classes/sun/nio/cs/US_ASCII.java index bb84ab1bd4b..61c4948e949 100644 --- a/src/java.base/share/classes/sun/nio/cs/US_ASCII.java +++ b/src/java.base/share/classes/sun/nio/cs/US_ASCII.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2026, 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 @@ -139,6 +139,16 @@ public class US_ASCII return c < 0x80; } + public boolean canEncode(CharSequence cs) { + int length = cs.length(); + for (int i = 0; i < length; i++) { + if (!canEncode(cs.charAt(i))) { + return false; + } + } + return true; + } + public boolean isLegalReplacement(byte[] repl) { return (repl.length == 1 && repl[0] >= 0) || super.isLegalReplacement(repl); diff --git a/test/micro/org/openjdk/bench/java/nio/CharsetCanEncode.java b/test/micro/org/openjdk/bench/java/nio/CharsetCanEncode.java new file mode 100644 index 00000000000..ebfbc217a95 --- /dev/null +++ b/test/micro/org/openjdk/bench/java/nio/CharsetCanEncode.java @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2026, 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. + */ +package org.openjdk.bench.java.nio; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; + +import java.nio.charset.Charset; +import java.nio.charset.CharsetEncoder; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@Warmup(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS) +@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Thread) +@Fork(3) +public class CharsetCanEncode { + + private static final char ALEF_CHAR = '\u05d0'; + private static final String ALEF_STRING = "\u05d0"; + + // sun.nio.cs.US_ASCII + private CharsetEncoder ascii = Charset.forName("US-ASCII").newEncoder(); + + // sun.nio.cs.ISO_8859_1 + private CharsetEncoder iso88591 = Charset.forName("ISO-8859-1").newEncoder(); + + // sun.nio.cs.SingleByte + private CharsetEncoder iso88592 = Charset.forName("ISO-8859-2").newEncoder(); + + // sun.nio.cs.DoubleByte + private CharsetEncoder shiftjis = Charset.forName("Shift_JIS").newEncoder(); + + // sun.nio.cs.UTF_8 + private CharsetEncoder utf8 = Charset.forName("UTF-8").newEncoder(); + + // sun.nio.cs.UTF_16LE + private CharsetEncoder utf16le = Charset.forName("UTF-16LE").newEncoder(); + + @Benchmark + public boolean asciiCanEncodeCharYes() { + return ascii.canEncode('D'); + } + + @Benchmark + public boolean asciiCanEncodeStringYes() { + return ascii.canEncode("D"); + } + + @Benchmark + public boolean asciiCanEncodeCharNo() { + return ascii.canEncode(ALEF_CHAR); + } + + @Benchmark + public boolean asciiCanEncodeStringNo() { + return ascii.canEncode(ALEF_STRING); + } + + @Benchmark + public boolean iso88591CanEncodeCharYes() { + return iso88591.canEncode('D'); + } + + @Benchmark + public boolean iso88591CanEncodeStringYes() { + return iso88591.canEncode("D"); + } + + @Benchmark + public boolean iso88591CanEncodeCharNo() { + return iso88591.canEncode(ALEF_CHAR); + } + + @Benchmark + public boolean iso88591CanEncodeStringNo() { + return iso88591.canEncode(ALEF_STRING); + } + + @Benchmark + public boolean iso88592CanEncodeCharYes() { + return iso88592.canEncode('D'); + } + + @Benchmark + public boolean iso88592CanEncodeStringYes() { + return iso88592.canEncode("D"); + } + + @Benchmark + public boolean iso88592CanEncodeCharNo() { + return iso88592.canEncode(ALEF_CHAR); + } + + @Benchmark + public boolean iso88592CanEncodeStringNo() { + return iso88592.canEncode(ALEF_STRING); + } + + @Benchmark + public boolean shiftjisCanEncodeCharYes() { + return shiftjis.canEncode('D'); + } + + @Benchmark + public boolean shiftjisCanEncodeStringYes() { + return shiftjis.canEncode("D"); + } + + @Benchmark + public boolean shiftjisCanEncodeCharNo() { + return shiftjis.canEncode(ALEF_CHAR); + } + + @Benchmark + public boolean shiftjisCanEncodeStringNo() { + return shiftjis.canEncode(ALEF_STRING); + } + + @Benchmark + public boolean utf8CanEncodeCharYes() { + return utf8.canEncode('D'); + } + + @Benchmark + public boolean utf8CanEncodeStringYes() { + return utf8.canEncode("D"); + } + + @Benchmark + public boolean utf8CanEncodeCharNo() { + return utf8.canEncode(Character.MIN_SURROGATE); + } + + @Benchmark + public boolean utf8CanEncodeStringNo() { + return utf8.canEncode(String.valueOf(Character.MIN_SURROGATE)); + } + + @Benchmark + public boolean utf16leCanEncodeCharYes() { + return utf16le.canEncode('D'); + } + + @Benchmark + public boolean utf16leCanEncodeStringYes() { + return utf16le.canEncode("D"); + } + + @Benchmark + public boolean utf16leCanEncodeCharNo() { + return utf16le.canEncode(Character.MIN_SURROGATE); + } + + @Benchmark + public boolean utf16leCanEncodeStringNo() { + return utf16le.canEncode(String.valueOf(Character.MIN_SURROGATE)); + } +} From 479ac8b2fdfbb64d26b34ff72abd61a1ce5f6c87 Mon Sep 17 00:00:00 2001 From: Matthias Baesken Date: Tue, 27 Jan 2026 13:30:14 +0000 Subject: [PATCH 077/105] 8376281: Remove USE_XLC_BUILTINS macro usage in AIX code Reviewed-by: mdoerr, clanger --- src/hotspot/os_cpu/aix_ppc/os_aix_ppc.cpp | 8 ++------ src/hotspot/os_cpu/aix_ppc/prefetch_aix_ppc.inline.hpp | 10 +--------- 2 files changed, 3 insertions(+), 15 deletions(-) diff --git a/src/hotspot/os_cpu/aix_ppc/os_aix_ppc.cpp b/src/hotspot/os_cpu/aix_ppc/os_aix_ppc.cpp index afef21b091a..3ab81697280 100644 --- a/src/hotspot/os_cpu/aix_ppc/os_aix_ppc.cpp +++ b/src/hotspot/os_cpu/aix_ppc/os_aix_ppc.cpp @@ -1,6 +1,6 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. - * Copyright (c) 2012, 2025 SAP SE. All rights reserved. + * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2026 SAP SE. 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 @@ -412,12 +412,8 @@ run_stub: } void os::Aix::init_thread_fpu_state(void) { -#if !defined(USE_XLC_BUILTINS) // Disable FP exceptions. __asm__ __volatile__ ("mtfsfi 6,0"); -#else - __mtfsfi(6, 0); -#endif } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/hotspot/os_cpu/aix_ppc/prefetch_aix_ppc.inline.hpp b/src/hotspot/os_cpu/aix_ppc/prefetch_aix_ppc.inline.hpp index c741335b5f0..d9dac0e231f 100644 --- a/src/hotspot/os_cpu/aix_ppc/prefetch_aix_ppc.inline.hpp +++ b/src/hotspot/os_cpu/aix_ppc/prefetch_aix_ppc.inline.hpp @@ -1,6 +1,6 @@ /* * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved. - * Copyright (c) 2012, 2013 SAP SE. All rights reserved. + * Copyright (c) 2012, 2026 SAP SE. 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 @@ -29,29 +29,21 @@ // Included in runtime/prefetch.inline.hpp inline void Prefetch::read(const void *loc, intx interval) { -#if !defined(USE_XLC_BUILTINS) __asm__ __volatile__ ( " dcbt 0, %0 \n" : : /*%0*/"r" ( ((address)loc) +((long)interval) ) //: ); -#else - __dcbt(((address)loc) +((long)interval)); -#endif } inline void Prefetch::write(void *loc, intx interval) { -#if !defined(USE_XLC_BUILTINS) __asm__ __volatile__ ( " dcbtst 0, %0 \n" : : /*%0*/"r" ( ((address)loc) +((long)interval) ) //: ); -#else - __dcbtst( ((address)loc) +((long)interval) ); -#endif } #endif // OS_CPU_AIX_PPC_PREFETCH_AIX_PPC_INLINE_HPP From 64b0ae6be8a7b70ed4cc08333447e9b73bdcbaca Mon Sep 17 00:00:00 2001 From: Wang Haomin Date: Tue, 27 Jan 2026 14:21:44 +0000 Subject: [PATCH 078/105] 8376276: Add javafx to allowed-list of CheckFiles Reviewed-by: erikj, kcr --- test/jdk/build/CheckFiles.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/jdk/build/CheckFiles.java b/test/jdk/build/CheckFiles.java index 5a915e881f0..7ef5b803d2d 100644 --- a/test/jdk/build/CheckFiles.java +++ b/test/jdk/build/CheckFiles.java @@ -106,6 +106,8 @@ public class CheckFiles { allowedEndingsLibDir.add("psfont.properties.ja"); allowedEndingsLibDir.add("src.zip"); allowedEndingsLibDir.add("tzdb.dat"); + allowedEndingsLibDir.add("javafx-swt.jar"); + allowedEndingsLibDir.add("javafx.properties"); if (Platform.isWindows()) { allowedEndingsLibDir.add(".lib"); allowedEndingsLibDir.add("tzmappings"); From bbb4b0d498900f929225233008bbdbafaae5d709 Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Tue, 27 Jan 2026 14:51:04 +0000 Subject: [PATCH 079/105] 8376277: Migrate java/lang/reflect tests away from TestNG Reviewed-by: alanb --- .../AccessibleObject/CanAccessTest.java | 41 ++--- .../ModuleSetAccessibleTest.java | 75 +++------ .../TrySetAccessibleTest.java | 79 ++++----- .../java/lang/reflect/ChainedReflection.java | 42 +++-- .../FilterNotMostSpecific.java | 22 +-- .../DefaultStaticInvokeTest.java | 70 ++++---- .../DefaultStaticTestData.java | 16 +- .../java/lang/reflect/Field/NegativeTest.java | 159 +++++------------- .../lang/reflect/Generics/ThreadSafety.java | 9 +- .../lang/reflect/IllegalArgumentsTest.java | 8 +- .../lang/reflect/Method/MethodArityLimit.java | 18 +- .../reflect/MethodHandleAccessorsTest.java | 70 ++++---- .../lang/reflect/Proxy/DefaultMethods.java | 127 ++++++-------- .../reflect/Proxy/HiddenProxyInterface.java | 15 +- .../reflect/Proxy/LazyInitializationTest.java | 13 +- .../reflect/Proxy/ProxyClassAccessTest.java | 30 ++-- .../lang/reflect/Proxy/ProxyLayerTest.java | 32 ++-- .../java/lang/reflect/Proxy/ProxyTest.java | 20 +-- .../reflect/Proxy/SealedInterfaceTest.java | 15 +- .../java/lang/reflect/Proxy/TestVarArgs.java | 45 +++-- .../nonPublicProxy/DefaultMethodProxy.java | 40 ++--- .../annotationSharing/AnnotationSharing.java | 6 +- .../reflect/callerCache/CustomLoaderTest.java | 36 ++-- .../ReflectionCallerCacheTest.java | 23 +-- .../records/CheckEqualityIsBasedOnFields.java | 22 ++- .../lang/reflect/records/IsRecordTest.java | 44 ++--- .../reflect/records/RecordReflectionTest.java | 81 +++++---- .../SealedClassesReflectionTest.java | 59 ++++--- 28 files changed, 511 insertions(+), 706 deletions(-) diff --git a/test/jdk/java/lang/reflect/AccessibleObject/CanAccessTest.java b/test/jdk/java/lang/reflect/AccessibleObject/CanAccessTest.java index 45e2502b601..ac7a1bad31b 100644 --- a/test/jdk/java/lang/reflect/AccessibleObject/CanAccessTest.java +++ b/test/jdk/java/lang/reflect/AccessibleObject/CanAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -21,11 +21,11 @@ * questions. */ -/** +/* * @test * @build CanAccessTest * @modules java.base/jdk.internal.misc:+open - * @run testng/othervm CanAccessTest + * @run junit/othervm CanAccessTest * @summary Test AccessibleObject::canAccess method */ @@ -34,31 +34,29 @@ import java.lang.reflect.Method; import java.security.SecureClassLoader; import jdk.internal.misc.Unsafe; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; -@Test public class CanAccessTest { private static Unsafe INSTANCE = Unsafe.getUnsafe(); /** * null object parameter for Constructor */ + @Test public void testConstructor() throws Exception { Constructor ctor = Unsafe.class.getDeclaredConstructor(); assertFalse(ctor.canAccess(null)); assertTrue(ctor.trySetAccessible()); - try { - // non-null object parameter - ctor.canAccess(INSTANCE); - assertTrue(false); - } catch (IllegalArgumentException expected) {} + // non-null object parameter + assertThrows(IllegalArgumentException.class, () -> ctor.canAccess(INSTANCE)); } /** * Test protected constructors */ + @Test public void testProtectedConstructor() throws Exception { TestLoader.testProtectedConstructorNonOpenedPackage(); @@ -69,21 +67,20 @@ public class CanAccessTest { /** * null object parameter for static members */ + @Test public void testStaticMember() throws Exception { Method m = Unsafe.class.getDeclaredMethod("throwIllegalAccessError"); assertFalse(m.canAccess(null)); assertTrue(m.trySetAccessible()); - try { - // non-null object parameter - m.canAccess(INSTANCE); - assertTrue(false); - } catch (IllegalArgumentException expected) { } + // non-null object parameter + assertThrows(IllegalArgumentException.class, () -> m.canAccess(INSTANCE)); } /** * Test protected static */ + @Test public void testProtectedStatic() throws Exception { Method m = TestLoader.testProtectedStatic(); assertFalse(m.canAccess(null)); @@ -93,28 +90,24 @@ public class CanAccessTest { * the specified object must be an instance of the declaring class * for instance members */ + @Test public void testInstanceMethod() throws Exception { Method m = Unsafe.class.getDeclaredMethod("allocateMemory0", long.class); assertFalse(m.canAccess(INSTANCE)); - try { - m.canAccess(null); - assertTrue(false); - } catch (IllegalArgumentException expected) { } + assertThrows(IllegalArgumentException.class, () -> m.canAccess(null)); } /** * the specified object must be an instance of the declaring class * for instance members */ + @Test public void testInvalidInstanceObject() throws Exception { Class clazz = Class.forName("sun.security.x509.X500Name"); Method m = clazz.getDeclaredMethod("size"); - try { - m.canAccess(INSTANCE); - assertTrue(false); - } catch (IllegalArgumentException expected) { } + assertThrows(IllegalArgumentException.class, () -> m.canAccess(INSTANCE)); } diff --git a/test/jdk/java/lang/reflect/AccessibleObject/ModuleSetAccessibleTest.java b/test/jdk/java/lang/reflect/AccessibleObject/ModuleSetAccessibleTest.java index 45cebdb552b..7d79a1ac49b 100644 --- a/test/jdk/java/lang/reflect/AccessibleObject/ModuleSetAccessibleTest.java +++ b/test/jdk/java/lang/reflect/AccessibleObject/ModuleSetAccessibleTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -21,12 +21,12 @@ * questions. */ -/** +/* * @test * @build ModuleSetAccessibleTest * @modules java.base/java.lang:open * java.base/jdk.internal.misc:+open - * @run testng/othervm ModuleSetAccessibleTest + * @run junit/othervm ModuleSetAccessibleTest * @summary Test java.lang.reflect.AccessibleObject with modules */ @@ -40,22 +40,19 @@ import java.security.ProtectionDomain; import jdk.internal.misc.Unsafe; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; -@Test public class ModuleSetAccessibleTest { /** * Invoke a private constructor on a public class in an exported package */ + @Test public void testPrivateConstructorInExportedPackage() throws Exception { Constructor ctor = Unsafe.class.getDeclaredConstructor(); - try { - ctor.newInstance(); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> ctor.newInstance()); ctor.setAccessible(true); Unsafe unsafe = (Unsafe) ctor.newInstance(); @@ -65,34 +62,26 @@ public class ModuleSetAccessibleTest { /** * Invoke a private method on a public class in an exported package */ + @Test public void testPrivateMethodInExportedPackage() throws Exception { Method m = Unsafe.class.getDeclaredMethod("throwIllegalAccessError"); - try { - m.invoke(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> m.invoke(null)); m.setAccessible(true); - try { - m.invoke(null); - assertTrue(false); - } catch (InvocationTargetException e) { - // thrown by throwIllegalAccessError - assertTrue(e.getCause() instanceof IllegalAccessError); - } + InvocationTargetException e = assertThrows(InvocationTargetException.class, () -> + m.invoke(null)); + // thrown by throwIllegalAccessError + assertInstanceOf(IllegalAccessError.class, e.getCause()); } /** * Access a private field in a public class that is an exported package */ + @Test public void testPrivateFieldInExportedPackage() throws Exception { Field f = Unsafe.class.getDeclaredField("theUnsafe"); - - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> f.get(null)); f.setAccessible(true); Unsafe unsafe = (Unsafe) f.get(null); @@ -102,19 +91,14 @@ public class ModuleSetAccessibleTest { /** * Invoke a public constructor on a public class in a non-exported package */ + @Test public void testPublicConstructorInNonExportedPackage() throws Exception { Class clazz = Class.forName("sun.security.x509.X500Name"); Constructor ctor = clazz.getConstructor(String.class); - try { - ctor.newInstance("cn=duke"); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> ctor.newInstance("cn=duke")); - try { - ctor.setAccessible(true); - assertTrue(false); - } catch (InaccessibleObjectException expected) { } + assertThrows(InaccessibleObjectException.class, () -> ctor.setAccessible(true)); ctor.setAccessible(false); // should succeed } @@ -123,19 +107,14 @@ public class ModuleSetAccessibleTest { /** * Access a public field in a public class that in a non-exported package */ + @Test public void testPublicFieldInNonExportedPackage() throws Exception { Class clazz = Class.forName("sun.security.x509.X500Name"); Field f = clazz.getField("SERIALNUMBER_OID"); - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> f.get(null)); - try { - f.setAccessible(true); - assertTrue(false); - } catch (InaccessibleObjectException expected) { } + assertThrows(InaccessibleObjectException.class, () -> f.setAccessible(true)); f.setAccessible(false); // should succeed } @@ -144,6 +123,7 @@ public class ModuleSetAccessibleTest { /** * Test that the Class constructor cannot be make accessible. */ + @Test public void testJavaLangClass() throws Exception { // non-public constructor @@ -152,15 +132,8 @@ public class ModuleSetAccessibleTest { ProtectionDomain.class, boolean.class, char.class); AccessibleObject[] ctors = { ctor }; - try { - ctor.setAccessible(true); - assertTrue(false); - } catch (SecurityException expected) { } - - try { - AccessibleObject.setAccessible(ctors, true); - assertTrue(false); - } catch (SecurityException expected) { } + assertThrows(SecurityException.class, () -> ctor.setAccessible(true)); + assertThrows(SecurityException.class, () -> AccessibleObject.setAccessible(ctors, true)); // should succeed ctor.setAccessible(false); diff --git a/test/jdk/java/lang/reflect/AccessibleObject/TrySetAccessibleTest.java b/test/jdk/java/lang/reflect/AccessibleObject/TrySetAccessibleTest.java index 774ee4d1dad..bd4d0fab23f 100644 --- a/test/jdk/java/lang/reflect/AccessibleObject/TrySetAccessibleTest.java +++ b/test/jdk/java/lang/reflect/AccessibleObject/TrySetAccessibleTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -21,14 +21,14 @@ * questions. */ -/** +/* * @test * @build TrySetAccessibleTest * @modules java.base/java.lang:open * java.base/jdk.internal.module * java.base/jdk.internal.perf * java.base/jdk.internal.misc:+open - * @run testng/othervm TrySetAccessibleTest + * @run junit/othervm TrySetAccessibleTest * @summary Test AccessibleObject::trySetAccessible method */ @@ -43,21 +43,18 @@ import jdk.internal.module.ModulePath; import jdk.internal.perf.Perf; import java.security.ProtectionDomain; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; -@Test public class TrySetAccessibleTest { /** * Invoke a private constructor on a public class in an exported package */ + @Test public void testPrivateConstructorInExportedPackage() throws Exception { Constructor ctor = Perf.class.getDeclaredConstructor(); - try { - ctor.newInstance(); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> ctor.newInstance()); assertFalse(ctor.trySetAccessible()); assertFalse(ctor.canAccess(null)); @@ -66,13 +63,11 @@ public class TrySetAccessibleTest { /** * Invoke a private constructor on a public class in an open package */ + @Test public void testPrivateConstructorInOpenedPackage() throws Exception { Constructor ctor = Unsafe.class.getDeclaredConstructor(); - try { - ctor.newInstance(); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> ctor.newInstance()); assertTrue(ctor.trySetAccessible()); assertTrue(ctor.canAccess(null)); @@ -82,12 +77,10 @@ public class TrySetAccessibleTest { /** * Invoke a private method on a public class in an exported package */ + @Test public void testPrivateMethodInExportedPackage() throws Exception { Method m = ModulePath.class.getDeclaredMethod("packageName", String.class); - try { - m.invoke(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> m.invoke(null)); assertFalse(m.trySetAccessible()); assertFalse(m.canAccess(null)); @@ -97,54 +90,42 @@ public class TrySetAccessibleTest { /** * Invoke a private method on a public class in an open package */ + @Test public void testPrivateMethodInOpenedPackage() throws Exception { Method m = Unsafe.class.getDeclaredMethod("throwIllegalAccessError"); assertFalse(m.canAccess(null)); - try { - m.invoke(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> m.invoke(null)); assertTrue(m.trySetAccessible()); assertTrue(m.canAccess(null)); - try { - m.invoke(null); - assertTrue(false); - } catch (InvocationTargetException e) { - // thrown by throwIllegalAccessError - assertTrue(e.getCause() instanceof IllegalAccessError); - } + + InvocationTargetException e = assertThrows(InvocationTargetException.class, () -> + m.invoke(null)); + assertInstanceOf(IllegalAccessError.class, e.getCause()); } /** * Invoke a private method on a public class in an exported package */ + @Test public void testPrivateFieldInExportedPackage() throws Exception { Field f = Perf.class.getDeclaredField("instance"); - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> f.get(null)); assertFalse(f.trySetAccessible()); assertFalse(f.canAccess(null)); - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) {} + assertThrows(IllegalAccessException.class, () -> f.get(null)); } /** * Access a private field in a public class that is an exported package */ + @Test public void testPrivateFieldInOpenedPackage() throws Exception { Field f = Unsafe.class.getDeclaredField("theUnsafe"); - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> f.get(null)); assertTrue(f.trySetAccessible()); assertTrue(f.canAccess(null)); @@ -155,32 +136,29 @@ public class TrySetAccessibleTest { /** * Invoke a public constructor on a public class in a non-exported package */ + @Test public void testPublicConstructorInNonExportedPackage() throws Exception { Class clazz = Class.forName("sun.security.x509.X500Name"); Constructor ctor = clazz.getConstructor(String.class); - try { - ctor.newInstance("cn=duke"); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> ctor.newInstance("cn=duke")); assertFalse(ctor.trySetAccessible()); assertFalse(ctor.canAccess(null)); - assertTrue(ctor.trySetAccessible() == ctor.isAccessible()); + assertFalse(ctor.trySetAccessible()); + assertFalse(ctor.isAccessible()); // should match trySetAccessible } /** * Access a public field in a public class that in a non-exported package */ + @Test public void testPublicFieldInNonExportedPackage() throws Exception { Class clazz = Class.forName("sun.security.x509.X500Name"); Field f = clazz.getField("SERIALNUMBER_OID"); - try { - f.get(null); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> f.get(null)); assertFalse(f.trySetAccessible()); assertFalse(f.canAccess(null)); @@ -190,6 +168,7 @@ public class TrySetAccessibleTest { /** * Test that the Class constructor cannot be make accessible. */ + @Test public void testJavaLangClass() throws Exception { // non-public constructor diff --git a/test/jdk/java/lang/reflect/ChainedReflection.java b/test/jdk/java/lang/reflect/ChainedReflection.java index 212a70345cd..bd76cd13fc8 100644 --- a/test/jdk/java/lang/reflect/ChainedReflection.java +++ b/test/jdk/java/lang/reflect/ChainedReflection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -23,9 +23,11 @@ /* * @test - * @run testng/othervm ChainedReflection + * @run junit/othervm ChainedReflection * @summary Test Method::invoke and Constructor::newInstance chained calls that * should wrap NPE in InvocationTargetException properly + * @comment This test is not using assertThrows given lambdas may affect the + * exception stack trace and therefore test anticipations */ import java.lang.reflect.Constructor; @@ -33,24 +35,28 @@ import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import java.util.Optional; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; public class ChainedReflection { - public ChainedReflection() {} - ChainedReflection(Void dummy) throws ReflectiveOperationException { - Method m = ChainedReflection.class.getMethod("throwNPE"); - try { - m.invoke(null); - } catch (InvocationTargetException e) { - Throwable t = e.getTargetException(); - if (t instanceof NullPointerException npe) { - throw npe; - } else { - throw new RuntimeException("Test failed (InvocationTargetException didn't wrap NullPointerException)"); + // This inner class is declared with a constructor that ctorCallMethodInvoke + // reflects on. Such a constructor cannot be declared in ChainedReflection + // because JUnit does not allow a test class to declare multiple constructors. + class Inner { + Inner() throws ReflectiveOperationException { + Method m = ChainedReflection.class.getMethod("throwNPE"); + try { + m.invoke(null); + } catch (InvocationTargetException e) { + Throwable t = e.getTargetException(); + if (t instanceof NullPointerException npe) { + throw npe; + } else { + throw new RuntimeException("Test failed (InvocationTargetException didn't wrap NullPointerException)"); + } + } catch (Throwable t) { + throw new RuntimeException("Test failed (Unexpected exception)", t); } - } catch (Throwable t) { - throw new RuntimeException("Test failed (Unexpected exception)", t); } } @@ -105,9 +111,9 @@ public class ChainedReflection { */ @Test public void ctorCallMethodInvoke() throws ReflectiveOperationException { - Constructor ctor = ChainedReflection.class.getDeclaredConstructor(Void.class); + Constructor ctor = ChainedReflection.Inner.class.getDeclaredConstructor(ChainedReflection.class); try { - ctor.newInstance((Void)null); + ctor.newInstance(this); } catch (InvocationTargetException e) { Throwable t = e.getTargetException(); if (!(t instanceof NullPointerException)) { diff --git a/test/jdk/java/lang/reflect/DefaultMethodMembers/FilterNotMostSpecific.java b/test/jdk/java/lang/reflect/DefaultMethodMembers/FilterNotMostSpecific.java index 1992f31d5de..b8738a383b0 100644 --- a/test/jdk/java/lang/reflect/DefaultMethodMembers/FilterNotMostSpecific.java +++ b/test/jdk/java/lang/reflect/DefaultMethodMembers/FilterNotMostSpecific.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2026, 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 @@ -26,7 +26,7 @@ * @bug 8029674 * @summary Verify that the right interface methods are returned by * Class.getMethod() and Class.getMethods() - * @run testng FilterNotMostSpecific + * @run junit FilterNotMostSpecific */ import java.lang.reflect.*; @@ -39,14 +39,14 @@ import java.util.HashMap; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class FilterNotMostSpecific { - @Test(dataProvider="getCases") + @ParameterizedTest + @MethodSource("getCases") public void testGetMethod(Class iface) { boolean match = false; MethodDesc[] expectedMethods = iface.getAnnotationsByType(MethodDesc.class); @@ -67,7 +67,8 @@ public class FilterNotMostSpecific { assert(match); } - @Test(dataProvider="getCases") + @ParameterizedTest + @MethodSource("getCases") public void testGetMethods(Class iface) { List foundMethods = filterObjectMethods(iface.getMethods()); MethodDesc[] expectedMethods = iface.getAnnotationsByType(MethodDesc.class); @@ -84,7 +85,7 @@ public class FilterNotMostSpecific { fail("On: "+ iface +"\nDid not find " + toMethodString(expected) + " among " + foundMethods); } - assertEquals(foundMethods.size(), expectedMethods.length, + assertEquals(expectedMethods.length, foundMethods.size(), "\non: " + iface + "\nexpected: " + toMethodStrings(expectedMethods) + "\nfound: " + foundMethods + "\n"); @@ -565,8 +566,7 @@ public class FilterNotMostSpecific { @MethodDesc(name="m", declaringClass=F.class, isGetMethodReturn=true) abstract class H extends G implements F {} - @DataProvider - public Object[][] getCases() { return CASES; } + public static Object[][] getCases() { return CASES; } public static final Class[][] CASES = { { K1.class }, { K1M.class }, diff --git a/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java b/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java index 215ee3dd66a..ff7d12502b3 100644 --- a/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java +++ b/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticInvokeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2026, 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 @@ -27,7 +27,7 @@ * in interfaces and/or in inheritance * @bug 7184826 * @build helper.Mod helper.Declared DefaultStaticTestData - * @run testng DefaultStaticInvokeTest + * @run junit DefaultStaticInvokeTest * @author Yong Lu */ @@ -40,23 +40,19 @@ import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertNotNull; -import static org.testng.Assert.fail; -import org.testng.annotations.Test; - import static helper.Mod.*; import static helper.Declared.*; -import helper.Mod; +import static org.junit.jupiter.api.Assertions.*; +import helper.Mod; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class DefaultStaticInvokeTest { // getMethods(): Make sure getMethods returns the expected methods. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testGetMethods(String testTarget, Object param) throws Exception { testMethods(ALL_METHODS, testTarget, param); @@ -64,8 +60,8 @@ public class DefaultStaticInvokeTest { // getDeclaredMethods(): Make sure getDeclaredMethods returns the expected methods. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testGetDeclaredMethods(String testTarget, Object param) throws Exception { testMethods(DECLARED_ONLY, testTarget, param); @@ -73,8 +69,8 @@ public class DefaultStaticInvokeTest { // getMethod(): Make sure that getMethod finds all methods it should find. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testGetMethod(String testTarget, Object param) throws Exception { @@ -91,8 +87,8 @@ public class DefaultStaticInvokeTest { // getMethod(): Make sure that getMethod does *not* find certain methods. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testGetMethodSuperInterfaces(String testTarget, Object param) throws Exception { @@ -124,8 +120,8 @@ public class DefaultStaticInvokeTest { // Method.invoke(): Make sure Method.invoke returns the expected value. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testMethodInvoke(String testTarget, Object param) throws Exception { Class typeUnderTest = Class.forName(testTarget); @@ -141,8 +137,8 @@ public class DefaultStaticInvokeTest { // MethodHandle.invoke(): Make sure MethodHandle.invoke returns the expected value. - @Test(dataProvider = "testCasesAll", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource({"DefaultStaticTestData#testClasses", "DefaultStaticTestData#testInterfaces"}) public void testMethodHandleInvoke(String testTarget, Object param) throws Throwable { Class typeUnderTest = Class.forName(testTarget); @@ -169,14 +165,14 @@ public class DefaultStaticInvokeTest { : (String) methodHandle.invoke(typeUnderTest.newInstance(), param); } - assertEquals(result, expectedReturn); + assertEquals(expectedReturn, result); } } // Lookup.findStatic / .findVirtual: Make sure IllegalAccessException is thrown as expected. - @Test(dataProvider = "testClasses", - dataProviderClass = DefaultStaticTestData.class) + @ParameterizedTest + @MethodSource("DefaultStaticTestData#testClasses") public void testIAE(String testTarget, Object param) throws ClassNotFoundException { @@ -189,14 +185,8 @@ public class DefaultStaticInvokeTest { if (mod != STATIC && typeUnderTest.isInterface()) { continue; } - Exception caught = null; - try { - getTestMH(typeUnderTest, mName, param, true); - } catch (Exception e) { - caught = e; - } - assertNotNull(caught); - assertEquals(caught.getClass(), IllegalAccessException.class); + assertThrowsExactly(IllegalAccessException.class, () -> + getTestMH(typeUnderTest, mName, param, true)); } } @@ -254,7 +244,7 @@ public class DefaultStaticInvokeTest { } } - assertEquals(myMethods.size(), expectedMethods.length); + assertEquals(expectedMethods.length, myMethods.size()); for (MethodDesc toTest : expectedMethods) { @@ -284,16 +274,15 @@ public class DefaultStaticInvokeTest { assertFalse(method.isDefault()); // Test invoke it - assertEquals(tryInvoke(method, null, param), expectedReturn); + assertEquals(expectedReturn, tryInvoke(method, null, param)); break; case DEFAULT: // if typeUnderTest is a class then instantiate and invoke if (!typeUnderTest.isInterface()) { - assertEquals(tryInvoke( + assertEquals(expectedReturn, tryInvoke( method, typeUnderTest, - param), - expectedReturn); + param)); } //assert candidate is default @@ -302,11 +291,10 @@ public class DefaultStaticInvokeTest { break; case REGULAR: // if typeUnderTest must be a class - assertEquals(tryInvoke( + assertEquals(expectedReturn, tryInvoke( method, typeUnderTest, - param), - expectedReturn); + param)); //assert candidate is neither default nor static assertFalse(Modifier.isStatic(method.getModifiers())); diff --git a/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java b/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java index 8049712569b..add991e3493 100644 --- a/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java +++ b/test/jdk/java/lang/reflect/DefaultStaticTest/DefaultStaticTestData.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2026, 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 @@ -27,12 +27,10 @@ * @author Yong Lu */ +import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import org.testng.annotations.DataProvider; -import org.testng.collections.Lists; - import static helper.Mod.*; import static helper.Declared.*; import helper.Mod; @@ -379,7 +377,6 @@ public class DefaultStaticTestData { * data is the name of the class under test Second data used in test as the * arguments used for the method call. */ - @DataProvider static Object[][] testClasses() { return new Object[][]{ {"TestClass1", null}, @@ -408,7 +405,6 @@ public class DefaultStaticTestData { * data is the name of the interface under test Second data used in test as * the arguments used for the method call. */ - @DataProvider static Object[][] testInterfaces() { return new Object[][]{ {"TestIF1", null}, @@ -438,12 +434,4 @@ public class DefaultStaticTestData { {"TestIF21", null}, }; } - - @DataProvider - static Object[][] testCasesAll() { - List result = Lists.newArrayList(); - result.addAll(Arrays.asList(testClasses())); - result.addAll(Arrays.asList(testInterfaces())); - return result.toArray(new Object[result.size()][]); - } } diff --git a/test/jdk/java/lang/reflect/Field/NegativeTest.java b/test/jdk/java/lang/reflect/Field/NegativeTest.java index fe1f2dd7480..186267f4458 100644 --- a/test/jdk/java/lang/reflect/Field/NegativeTest.java +++ b/test/jdk/java/lang/reflect/Field/NegativeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -21,20 +21,20 @@ * questions. */ -/** +/* * @test * @bug 8277451 * @summary Test exception thrown due to bad receiver and bad value on * Field with and without setAccessible(true) - * @run testng/othervm --enable-final-field-mutation=ALL-UNNAMED NegativeTest + * @run junit/othervm --enable-final-field-mutation=ALL-UNNAMED NegativeTest */ 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.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class NegativeTest { static class Fields { @@ -167,8 +167,7 @@ public class NegativeTest { } } - @DataProvider(name = "instanceFields") - private Object[][] instanceFields() { + private static Object[][] instanceFields() { return new Object[][]{ new Object[]{i_field}, new Object[]{c_field}, @@ -217,7 +216,8 @@ public class NegativeTest { * IllegalArgumentException is thrown if the receiver is of * a bad type. NullPointerException is thrown if the receiver is null. */ - @Test(dataProvider = "instanceFields") + @ParameterizedTest + @MethodSource("instanceFields") public void testReceiver(Field f) throws ReflectiveOperationException { f.get(INSTANCE); // good receiver @@ -231,15 +231,10 @@ public class NegativeTest { 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 - } + assertThrows(IllegalArgumentException.class, () -> f.get(badObj)); Class fType = f.getType(); if (fType.isPrimitive()) { - try { + assertThrows(IllegalArgumentException.class, () -> { switch (fType.descriptorString()) { case "B" -> f.getByte(badObj); case "C" -> f.getChar(badObj); @@ -250,10 +245,7 @@ public class NegativeTest { case "S" -> f.getShort(badObj); case "Z" -> f.getBoolean(badObj); } - fail("expected IllegalArgumentException"); - } catch (IllegalArgumentException e) { - // expected - } + }); } } @@ -262,16 +254,11 @@ public class NegativeTest { */ 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 - } + assertThrows(NullPointerException.class, () -> f.get(null)); Class fType = f.getType(); if (fType.isPrimitive()) { - try { + assertThrows(NullPointerException.class, () -> { switch (fType.descriptorString()) { case "B" -> f.getByte(null); case "C" -> f.getChar(null); @@ -282,15 +269,11 @@ public class NegativeTest { case "S" -> f.getShort(null); case "Z" -> f.getBoolean(null); } - fail("expected NullPointerException"); - } catch (NullPointerException e) { - // expected - } + }); } } - @DataProvider(name = "writeableFields") - private Object[][] writeableFields() { + private static Object[][] writeableFields() { Fields obj = new Fields(); return new Object[][]{ // instance fields with and without setAccessible(true) @@ -352,7 +335,8 @@ public class NegativeTest { * NullPointerException is thrown if the receiver of an instance field is null. * The receiver is checked */ - @Test(dataProvider = "writeableFields") + @ParameterizedTest + @MethodSource("writeableFields") public void testSetValue(Field f, Object obj, Object value) throws IllegalAccessException { f.set(obj, value); Class fType = f.getType(); @@ -369,25 +353,14 @@ public class NegativeTest { } // test null value only if it's primitive type - try { - f.set(obj, null); - fail("expected IllegalArgumentException"); - } catch (IllegalArgumentException e) { - // expected - } + assertThrows(IllegalArgumentException.class, () -> f.set(obj, null)); } Object badValue = new NegativeTest(); - try { - f.set(obj, badValue); - fail("expected IllegalArgumentException"); - } catch (IllegalArgumentException e) { - // expected - } + assertThrows(IllegalArgumentException.class, () -> f.set(obj, badValue)); } - @DataProvider(name = "readOnlyFinalFields") - private Object[][] readOnlyFinalFields() { + private static Object[][] readOnlyFinalFields() { Object obj = INSTANCE; return new Object[][]{ // instance final fields @@ -427,19 +400,15 @@ public class NegativeTest { * IllegalAccessException is thrown regardless of whether the value * is of a bad type or not. */ - @Test(dataProvider = "readOnlyFinalFields") + @ParameterizedTest + @MethodSource("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 - } + assertThrows(IllegalAccessException.class, () -> f.set(obj, value)); Class fType = f.getType(); if (fType.isPrimitive()) { - try { + assertThrows(IllegalAccessException.class, () -> { switch (fType.descriptorString()) { case "B" -> f.setByte(obj, ((Byte)value).byteValue()); case "C" -> f.setChar(obj, ((Character)value).charValue()); @@ -450,33 +419,17 @@ public class NegativeTest { 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 - } + assertThrows(IllegalAccessException.class, () -> f.set(obj, null)); } Object badValue = new NegativeTest(); - try { - f.set(obj, badValue); - fail("expected IllegalAccessException"); - } catch (IllegalAccessException e) { - // expected - } + assertThrows(IllegalAccessException.class, () -> f.set(obj, badValue)); } - - - @DataProvider(name = "finalInstanceFields") - private Object[][] finalInstanceFields() { + private static Object[][] finalInstanceFields() { return new Object[][]{ new Object[]{fi_field, Integer.valueOf(10)}, new Object[]{fc_field, Character.valueOf('c')}, @@ -497,54 +450,27 @@ public class NegativeTest { * The receiver is checked before the access check is performed and * also before the value is checked. */ - @Test(dataProvider = "finalInstanceFields") + @ParameterizedTest + @MethodSource("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); - } + assertThrows(IllegalArgumentException.class, () -> f.set(badReceiver, value)); // 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); - } + assertThrows(IllegalArgumentException.class, () -> f.set(badReceiver, badValue)); // 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); - } + assertThrows(NullPointerException.class, () -> f.set(null, value)); // 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); - } + assertThrows(NullPointerException.class, () -> f.set(null, badValue)); Class fType = f.getType(); if (fType.isPrimitive()) { // test bad receiver - try { + assertThrows(IllegalArgumentException.class, () -> { switch (fType.descriptorString()) { case "B" -> f.setByte(badReceiver, ((Byte) value).byteValue()); case "C" -> f.setChar(badReceiver, ((Character) value).charValue()); @@ -555,12 +481,9 @@ public class NegativeTest { 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 { + assertThrows(NullPointerException.class, () -> { switch (fType.descriptorString()) { case "B" -> f.setByte(null, ((Byte) value).byteValue()); case "C" -> f.setChar(null, ((Character) value).charValue()); @@ -571,11 +494,7 @@ public class NegativeTest { 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); - } + }); } } } diff --git a/test/jdk/java/lang/reflect/Generics/ThreadSafety.java b/test/jdk/java/lang/reflect/Generics/ThreadSafety.java index 1aa1a4e9386..81ca2ae488a 100644 --- a/test/jdk/java/lang/reflect/Generics/ThreadSafety.java +++ b/test/jdk/java/lang/reflect/Generics/ThreadSafety.java @@ -21,17 +21,16 @@ * questions. */ -/** +/* * @test * @bug 8062771 8016236 * @summary Test publication of Class objects via a data race - * @run testng ThreadSafety + * @run junit ThreadSafety */ import java.io.File; import java.net.URL; import java.net.URLClassLoader; -import java.nio.file.Path; import java.nio.file.Paths; import java.util.Collections; import java.util.concurrent.BrokenBarrierException; @@ -43,8 +42,8 @@ import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeoutException; import static java.util.concurrent.TimeUnit.SECONDS; -import static org.testng.Assert.*; -import org.testng.annotations.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** * A test resulting from an attempt to repro this failure (in guice): diff --git a/test/jdk/java/lang/reflect/IllegalArgumentsTest.java b/test/jdk/java/lang/reflect/IllegalArgumentsTest.java index 7260c04c10a..58115523a3d 100644 --- a/test/jdk/java/lang/reflect/IllegalArgumentsTest.java +++ b/test/jdk/java/lang/reflect/IllegalArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -25,12 +25,14 @@ * @test * @bug 8277964 * @summary Test IllegalArgumentException be thrown when an argument is invalid - * @run testng/othervm/timeout=720 IllegalArgumentsTest + * @comment Avoid using framework utilities; this is effectively a runtime test + * sensitive to stack traces + * @run junit/othervm/timeout=720 IllegalArgumentsTest */ import java.lang.reflect.Constructor; import java.lang.reflect.Method; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; public class IllegalArgumentsTest { static class T { diff --git a/test/jdk/java/lang/reflect/Method/MethodArityLimit.java b/test/jdk/java/lang/reflect/Method/MethodArityLimit.java index 536b3a5e317..05d4ef609ef 100644 --- a/test/jdk/java/lang/reflect/Method/MethodArityLimit.java +++ b/test/jdk/java/lang/reflect/Method/MethodArityLimit.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -24,18 +24,16 @@ /* * @test * @bug 8271820 - * @run testng/othervm MethodArityLimit + * @run junit/othervm MethodArityLimit * @summary Method exceeds the method handle arity limit (255). */ -import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.reflect.Method; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.fail; +import static org.junit.jupiter.api.Assertions.*; public class MethodArityLimit { @Test @@ -74,12 +72,10 @@ public class MethodArityLimit { 106L, 107L, 108L, 109L, 110L, 111L, 112L, 113L, 114L, 115L, 116L, 117L, 118L, 119L, 120L, 121L, 122L, 123L, 124L, 125L, 126L, 127); - assertEquals(resultViaMethod, 127); + assertEquals(127, resultViaMethod); - try { - MethodHandle mh = MethodHandles.lookup().unreflect(m); - fail("should fail in creating the method handle"); - } catch (IllegalArgumentException e) {} + var lookup = MethodHandles.lookup(); + assertThrows(IllegalArgumentException.class, () -> lookup.unreflect(m)); } public static long f(long a0, long a1, long a2, long a3, long a4, long a5, diff --git a/test/jdk/java/lang/reflect/MethodHandleAccessorsTest.java b/test/jdk/java/lang/reflect/MethodHandleAccessorsTest.java index b7e6b52b5dc..af72d8dec58 100644 --- a/test/jdk/java/lang/reflect/MethodHandleAccessorsTest.java +++ b/test/jdk/java/lang/reflect/MethodHandleAccessorsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -26,7 +26,7 @@ * @bug 8271820 8300924 * @modules java.base/jdk.internal.reflect * @summary Test compliance of ConstructorAccessor, FieldAccessor, MethodAccessor implementations - * @run testng/othervm --add-exports java.base/jdk.internal.reflect=ALL-UNNAMED -XX:-ShowCodeDetailsInExceptionMessages MethodHandleAccessorsTest + * @run junit/othervm -XX:-ShowCodeDetailsInExceptionMessages MethodHandleAccessorsTest */ import jdk.internal.reflect.ConstructorAccessor; @@ -44,8 +44,11 @@ import java.util.Objects; import java.util.function.IntUnaryOperator; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; public class MethodHandleAccessorsTest { public static void public_static_V() {} @@ -446,9 +449,7 @@ public class MethodHandleAccessorsTest { new InvocationTargetException(new IllegalArgumentException("IAE")) }; - - @DataProvider(name = "testNoArgMethods") - private Object[][] testNoArgMethods() { + private static Object[][] testNoArgMethods() { MethodHandleAccessorsTest inst = new MethodHandleAccessorsTest(); Object[] emptyArgs = new Object[]{}; return new Object[][] { @@ -468,8 +469,7 @@ public class MethodHandleAccessorsTest { }; } - @DataProvider(name = "testOneArgMethods") - private Object[][] testOneArgMethods() { + private static Object[][] testOneArgMethods() { MethodHandleAccessorsTest inst = new MethodHandleAccessorsTest(); Object wrongInst = new Object(); return new Object[][]{ @@ -497,8 +497,7 @@ public class MethodHandleAccessorsTest { }; } - @DataProvider(name = "testMultiArgMethods") - private Object[][] testMultiArgMethods() { + private static Object[][] testMultiArgMethods() { MethodHandleAccessorsTest inst = new MethodHandleAccessorsTest(); Class[] params_L3 = new Class[] { Object.class, Object.class, Object.class}; Class[] params_L4 = new Class[] { Object.class, Object.class, Object.class, Object.class}; @@ -515,8 +514,7 @@ public class MethodHandleAccessorsTest { }; } - @DataProvider(name = "testMethodsWithVarargs") - private Object[][] testMethodsWithVarargs() { + private static Object[][] testMethodsWithVarargs() { Class[] paramTypes = new Class[] { int[].class }; Class[] I_paramTypes = new Class[] { int.class, int[].class }; Class[] L_paramTypes = new Class[] { String.class, String[].class }; @@ -533,32 +531,35 @@ public class MethodHandleAccessorsTest { }; } - @Test(dataProvider = "testNoArgMethods") + @ParameterizedTest + @MethodSource("testNoArgMethods") public void testNoArgMethod(String methodname, Object target, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(MethodHandleAccessorsTest.class.getDeclaredMethod(methodname), target, args, expectedReturn, expectedExpections); } - @Test(dataProvider = "testOneArgMethods") + @ParameterizedTest + @MethodSource("testOneArgMethods") public void testOneArgMethod(String methodname, Class paramType, Object target, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(MethodHandleAccessorsTest.class.getDeclaredMethod(methodname, paramType), target, args, expectedReturn, expectedExpections); } - @Test(dataProvider = "testMultiArgMethods") + @ParameterizedTest + @MethodSource("testMultiArgMethods") public void testMultiArgMethod(String methodname, Class[] paramTypes, Object target, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(MethodHandleAccessorsTest.class.getDeclaredMethod(methodname, paramTypes), target, args, expectedReturn, expectedExpections); } - @Test(dataProvider = "testMethodsWithVarargs") + @ParameterizedTest + @MethodSource("testMethodsWithVarargs") public void testMethodsWithVarargs(String methodname, Class[] paramTypes, Object target, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(MethodHandleAccessorsTest.class.getDeclaredMethod(methodname, paramTypes), target, args, expectedReturn, expectedExpections); } - @DataProvider(name = "testConstructors") - private Object[][] testConstructors() { + private static Object[][] testConstructors() { return new Object[][]{ new Object[]{null, new Object[]{}, new Public(), noException}, new Object[]{null, null, new Public(), noException}, @@ -584,13 +585,13 @@ public class MethodHandleAccessorsTest { }; } - @Test(dataProvider = "testConstructors") + @ParameterizedTest + @MethodSource("testConstructors") public void testPublicConstructors(Class[] paramTypes, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(Public.class.getDeclaredConstructor(paramTypes), args, expectedReturn, expectedExpections); } - @DataProvider(name = "testMultiArgConstructors") - private Object[][] testMultiArgConstructors() { + private static Object[][] testMultiArgConstructors() { Class[] params_L3 = new Class[] { Object.class, Object.class, Object.class}; Class[] params_L4 = new Class[] { Object.class, Object.class, Object.class, Object.class}; Object o = "arg"; @@ -602,7 +603,8 @@ public class MethodHandleAccessorsTest { }; } - @Test(dataProvider = "testMultiArgConstructors") + @ParameterizedTest + @MethodSource("testMultiArgConstructors") public void testMultiArgConstructors(Class[] paramTypes, Object[] args, Object expectedReturn, Throwable[] expectedExpections) throws Exception { doTest(Public.class.getDeclaredConstructor(paramTypes), args, expectedReturn, expectedExpections); } @@ -616,8 +618,7 @@ public class MethodHandleAccessorsTest { doTest(Abstract.class.getDeclaredConstructor(), null, null, new InstantiationException()); } - @DataProvider(name = "throwException") - private Object[][] throwException() { + private static Object[][] throwException() { return new Object[][]{ new Object[] {new NullPointerException("NPE"), wrapped_npe}, new Object[] {new IllegalArgumentException("IAE"), wrapped_iae}, @@ -629,7 +630,8 @@ public class MethodHandleAccessorsTest { * Test Method::invoke and Constructor::newInstance to wrap NPE/CCE/IAE * thrown by the member */ - @Test(dataProvider = "throwException") + @ParameterizedTest + @MethodSource("throwException") public void testInvocationTargetException(Throwable ex, Throwable[] expectedExpections) throws Exception { Object[] args = new Object[] { ex }; // test static method @@ -646,8 +648,7 @@ public class MethodHandleAccessorsTest { doTest(applyAsIntMethod, intUnaryOp, new Object[]{12}, 12); } - @DataProvider(name = "readAccess") - private Object[][] readAccess() { + private static Object[][] readAccess() { String wrongInst = new String(); return new Object[][]{ new Object[]{"i", new Public(100), 100, noException}, @@ -657,8 +658,7 @@ public class MethodHandleAccessorsTest { new Object[]{"b", wrongInst, 0, cannot_get_field}, }; } - @DataProvider(name = "writeAccess") - private Object[][] writeAccess() { + private static Object[][] writeAccess() { Object o = new Object(); byte b = 1; return new Object[][]{ @@ -673,14 +673,16 @@ public class MethodHandleAccessorsTest { }; } - @Test(dataProvider = "readAccess") + @ParameterizedTest + @MethodSource("readAccess") public void testFieldReadAccess(String name, Object target, Object expectedValue, Throwable[] expectedExpections) throws Exception { Field f = Public.class.getDeclaredField(name); f.setAccessible(true); doTest(f, target, expectedValue, expectedExpections); } - @Test(dataProvider = "writeAccess") + @ParameterizedTest + @MethodSource("writeAccess") public void testFieldWriteAccess(String name, Object target, Object oldValue, Object newValue, Throwable[] expectedExpections) throws Exception { Field f = Public.class.getDeclaredField(name); f.setAccessible(true); @@ -693,8 +695,6 @@ public class MethodHandleAccessorsTest { Field f = Public.class.getDeclaredField("STATIC_FINAL"); doTest(f, new Public(), 1, noException); - try { - f.setInt(null, 100); - } catch (IllegalAccessException e) { } + assertThrows(IllegalAccessException.class, () -> f.setInt(null, 100)); } } diff --git a/test/jdk/java/lang/reflect/Proxy/DefaultMethods.java b/test/jdk/java/lang/reflect/Proxy/DefaultMethods.java index 48bb67f405e..e494e623119 100644 --- a/test/jdk/java/lang/reflect/Proxy/DefaultMethods.java +++ b/test/jdk/java/lang/reflect/Proxy/DefaultMethods.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -23,19 +23,19 @@ import java.io.IOException; import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -/** +/* * @test * @bug 8159746 - * @run testng DefaultMethods + * @run junit DefaultMethods * @summary Basic tests for Proxy::invokeSuper default method */ @@ -96,15 +96,11 @@ public class DefaultMethods { } private static Method findDefaultMethod(Class refc, Method m) { - try { - assertTrue(refc.isInterface()); + assertTrue(refc.isInterface()); - Method method = refc.getMethod(m.getName(), m.getParameterTypes()); - assertTrue(method.isDefault()); - return method; - } catch (NoSuchMethodException e) { - throw new RuntimeException(e); - } + Method method = assertDoesNotThrow(() -> refc.getMethod(m.getName(), m.getParameterTypes())); + assertTrue(method.isDefault()); + return method; } @Test @@ -115,12 +111,11 @@ public class DefaultMethods { return InvocationHandler.invokeDefault(o, findDefaultMethod(I2.class, method), params); }); I1 i1 = (I1) proxy; - assertEquals(i1.m(), 20); + assertEquals(20, i1.m()); } // a default method is declared in one of the proxy interfaces - @DataProvider(name = "defaultMethods") - private Object[][] defaultMethods() { + private static Object[][] defaultMethods() { return new Object[][]{ new Object[]{new Class[]{I1.class, I2.class}, true, 10}, new Object[]{new Class[]{I1.class, I3.class}, true, 10}, @@ -133,13 +128,14 @@ public class DefaultMethods { }; } - @Test(dataProvider = "defaultMethods") + @ParameterizedTest + @MethodSource("defaultMethods") public void testDefaultMethod(Class[] intfs, boolean isDefault, int expected) throws Throwable { InvocationHandler ih = (proxy, method, params) -> { System.out.format("invoking %s with parameters: %s%n", method, Arrays.toString(params)); switch (method.getName()) { case "m": - assertTrue(method.isDefault() == isDefault); + assertEquals(isDefault, method.isDefault()); assertTrue(Arrays.stream(proxy.getClass().getInterfaces()) .anyMatch(intf -> method.getDeclaringClass() == intf), Arrays.toString(proxy.getClass().getInterfaces())); @@ -156,13 +152,12 @@ public class DefaultMethods { Object proxy = Proxy.newProxyInstance(DefaultMethods.class.getClassLoader(), intfs, ih); Method m = proxy.getClass().getMethod("m"); int result = (int)m.invoke(proxy); - assertEquals(result, expected); + assertEquals(expected, result); } // a default method may be declared in a proxy interface or // inherited from a superinterface of a proxy interface - @DataProvider(name = "supers") - private Object[][] supers() { + private static Object[][] supers() { return new Object[][]{ // invoke "m" implemented in the first proxy interface // same as the method passed to InvocationHandler::invoke @@ -188,7 +183,8 @@ public class DefaultMethods { }; } - @Test(dataProvider = "supers") + @ParameterizedTest + @MethodSource("supers") public void testSuper(Class[] intfs, Class proxyInterface, int expected) throws Throwable { final InvocationHandler ih = (proxy, method, params) -> { switch (method.getName()) { @@ -203,21 +199,21 @@ public class DefaultMethods { Object proxy = Proxy.newProxyInstance(loader, intfs, ih); if (proxyInterface == I1.class) { I1 i1 = (I1) proxy; - assertEquals(i1.m(), expected); + assertEquals(expected, i1.m()); } else if (proxyInterface == I2.class) { I2 i2 = (I2) proxy; - assertEquals(i2.m(), expected); + assertEquals(expected, i2.m()); } else if (proxyInterface == I3.class) { I3 i3 = (I3) proxy; - assertEquals(i3.m(), expected); + assertEquals(expected, i3.m()); } else if (proxyInterface == I4.class) { I4 i4 = (I4) proxy; - assertEquals(i4.m(), expected); + assertEquals(expected, i4.m()); } else { throw new UnsupportedOperationException(proxyInterface.toString()); } // invoke via InvocationHandler.invokeDefaultMethod directly - assertEquals(InvocationHandler.invokeDefault(proxy, proxyInterface.getMethod("m")), expected); + assertEquals(expected, InvocationHandler.invokeDefault(proxy, proxyInterface.getMethod("m"))); } // invoke I12 default methods with parameters and var args @@ -236,12 +232,12 @@ public class DefaultMethods { }; ClassLoader loader = DefaultMethods.class.getClassLoader(); I12 i12 = (I12) Proxy.newProxyInstance(loader, new Class[] { I12.class }, ih); - assertEquals(i12.sum(1, 2), 3); - assertEquals(i12.concat(1, 2, 3, 4), new Object[]{1, 2, 3, 4}); + assertEquals(3, i12.sum(1, 2)); + assertArrayEquals(new Object[]{1, 2, 3, 4}, i12.concat(1, 2, 3, 4)); Method m = I12.class.getMethod("concat", Object.class, Object[].class); assertTrue(m.isDefault()); - assertEquals(InvocationHandler.invokeDefault(i12, m, 100, new Object[] {"foo", true, "bar"}), - new Object[] {100, "foo", true, "bar"}); + assertArrayEquals(new Object[] {100, "foo", true, "bar"}, (Object[]) + InvocationHandler.invokeDefault(i12, m, 100, new Object[] {"foo", true, "bar"})); } // test a no-arg default method with and without arguments passed in the invocation @@ -250,13 +246,13 @@ public class DefaultMethods { ClassLoader loader = DefaultMethods.class.getClassLoader(); Object proxy = Proxy.newProxyInstance(loader, new Class[]{I4.class}, HANDLER); Method m1 = I4.class.getMethod("m"); - assertTrue(m1.getDeclaringClass() == I4.class); + assertSame(I4.class, m1.getDeclaringClass()); assertTrue(m1.isDefault()); InvocationHandler.invokeDefault(proxy, m1); InvocationHandler.invokeDefault(proxy, m1, new Object[0]); Method m2 = I4.class.getMethod("mix", int.class, String.class); - assertTrue(m1.getDeclaringClass() == I4.class); + assertSame(I4.class, m1.getDeclaringClass()); assertTrue(m1.isDefault()); InvocationHandler.invokeDefault(proxy, m2, Integer.valueOf(100), "foo"); } @@ -267,38 +263,37 @@ public class DefaultMethods { I3 proxy = (I3)Proxy.newProxyInstance(loader, new Class[]{I3.class}, HANDLER); Method m = I3.class.getMethod("m3", String[].class); assertTrue(m.isVarArgs() && m.isDefault()); - assertEquals(proxy.m3("a", "b", "cde"), 5); - assertEquals(InvocationHandler.invokeDefault(proxy, m, (Object)new String[] { "a", "bc" }), 3); + assertEquals(5, proxy.m3("a", "b", "cde")); + assertEquals(3, InvocationHandler.invokeDefault(proxy, m, (Object)new String[] { "a", "bc" })); } /* * Invoke I12::m which is an abstract method */ - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void invokeAbstractMethod() throws Exception { ClassLoader loader = DefaultMethods.class.getClassLoader(); I12 proxy = (I12) Proxy.newProxyInstance(loader, new Class[]{I12.class}, HANDLER); Method method = I12.class.getMethod("m"); - assertTrue(method.getDeclaringClass() == I12.class); + assertSame(I12.class, method.getDeclaringClass()); assertFalse(method.isDefault()); - proxy.m(); + assertThrows(IllegalArgumentException.class, () -> proxy.m()); } /* * Invoke a non proxy (default) method with parameters */ - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void invokeNonProxyMethod() throws Throwable { ClassLoader loader = DefaultMethods.class.getClassLoader(); I3 proxy = (I3) Proxy.newProxyInstance(loader, new Class[]{I3.class}, HANDLER); Method m = I4.class.getMethod("mix", int.class, String.class); assertTrue(m.isDefault()); - InvocationHandler.invokeDefault(proxy, m); + assertThrows(IllegalArgumentException.class, () -> InvocationHandler.invokeDefault(proxy, m)); } // negative cases - @DataProvider(name = "negativeCases") - private Object[][] negativeCases() { + private static Object[][] negativeCases() { return new Object[][]{ // I4::m overrides I1::m and I2::m new Object[] { new Class[]{I4.class}, I1.class, "m" }, @@ -315,25 +310,20 @@ public class DefaultMethods { }; } - @Test(dataProvider = "negativeCases", expectedExceptions = {IllegalArgumentException.class}) + @ParameterizedTest + @MethodSource("negativeCases") public void testNegativeCase(Class[] interfaces, Class defc, String name) throws Throwable { ClassLoader loader = DefaultMethods.class.getClassLoader(); Object proxy = Proxy.newProxyInstance(loader, interfaces, HANDLER); - try { - Method method = defc.getDeclaredMethod(name); - InvocationHandler.invokeDefault(proxy, method); - } catch (Throwable e) { - System.out.format("%s method %s::%s exception thrown: %s%n", - Arrays.toString(interfaces), defc.getName(), name, e.getMessage()); - throw e; - } + Method method = defc.getDeclaredMethod(name); + assertThrows(IllegalArgumentException.class, () -> + InvocationHandler.invokeDefault(proxy, method)); } - @DataProvider(name = "illegalArguments") - private Object[][] illegalArguments() { - return new Object[][] { - new Object[] { new Object[0]}, + private static Object[] illegalArguments() { + return new Object[] { + new Object[] { null }, new Object[] { new Object[] { 100 }}, new Object[] { new Object[] { 100, "foo", 100 }}, new Object[] { new Object[] { 100L, "foo" }}, @@ -342,21 +332,18 @@ public class DefaultMethods { }; } - @Test(dataProvider = "illegalArguments", expectedExceptions = {IllegalArgumentException.class}) + @ParameterizedTest + @MethodSource("illegalArguments") public void testIllegalArgument(Object[] args) throws Throwable { ClassLoader loader = DefaultMethods.class.getClassLoader(); I4 proxy = (I4)Proxy.newProxyInstance(loader, new Class[]{I4.class}, HANDLER); Method m = I4.class.getMethod("mix", int.class, String.class); assertTrue(m.isDefault()); - if (args.length == 0) { - // substitute empty args with null since @DataProvider doesn't allow null array - args = null; - } - InvocationHandler.invokeDefault(proxy, m, args); + assertThrows(IllegalArgumentException.class, () -> + InvocationHandler.invokeDefault(proxy, m, args)); } - @DataProvider(name = "throwables") - private Object[][] throwables() { + private static Object[][] throwables() { return new Object[][] { new Object[] { new IOException() }, new Object[] { new IllegalArgumentException() }, @@ -367,16 +354,14 @@ public class DefaultMethods { }; } - @Test(dataProvider = "throwables") + @ParameterizedTest + @MethodSource("throwables") public void testInvocationException(Throwable exception) throws Throwable { ClassLoader loader = DefaultMethods.class.getClassLoader(); IX proxy = (IX)Proxy.newProxyInstance(loader, new Class[]{IX.class}, HANDLER); Method m = IX.class.getMethod("doThrow", Throwable.class); - try { - InvocationHandler.invokeDefault(proxy, m, exception); - } catch (Throwable e) { - assertEquals(e, exception); - } + assertSame(exception, assertThrows(Throwable.class, () -> + InvocationHandler.invokeDefault(proxy, m, exception))); } private static final InvocationHandler HANDLER = (proxy, method, params) -> { diff --git a/test/jdk/java/lang/reflect/Proxy/HiddenProxyInterface.java b/test/jdk/java/lang/reflect/Proxy/HiddenProxyInterface.java index e52d3671ab6..fbaf9db6325 100644 --- a/test/jdk/java/lang/reflect/Proxy/HiddenProxyInterface.java +++ b/test/jdk/java/lang/reflect/Proxy/HiddenProxyInterface.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -24,7 +24,7 @@ /* * @test * @bug 8250219 - * @run testng HiddenProxyInterface + * @run junit HiddenProxyInterface */ import java.lang.invoke.MethodHandles; @@ -35,8 +35,8 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class HiddenProxyInterface { private static final Path CLASSES_DIR = Paths.get(System.getProperty("test.classes")); @@ -45,18 +45,19 @@ public class HiddenProxyInterface { void m(); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testHiddenInterface() throws Exception { Path classFile = CLASSES_DIR.resolve("HiddenProxyInterface$Intf.class"); byte[] bytes = Files.readAllBytes(classFile); Class hiddenIntf = MethodHandles.lookup().defineHiddenClass(bytes, false).lookupClass(); - Proxy.newProxyInstance(HiddenProxyInterface.class.getClassLoader(), + assertThrows(IllegalArgumentException.class, () -> Proxy.newProxyInstance( + HiddenProxyInterface.class.getClassLoader(), new Class[]{ hiddenIntf }, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } - }); + })); } } diff --git a/test/jdk/java/lang/reflect/Proxy/LazyInitializationTest.java b/test/jdk/java/lang/reflect/Proxy/LazyInitializationTest.java index cb65904cfdb..2a223873275 100644 --- a/test/jdk/java/lang/reflect/Proxy/LazyInitializationTest.java +++ b/test/jdk/java/lang/reflect/Proxy/LazyInitializationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, 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 @@ -23,14 +23,15 @@ import java.lang.reflect.Proxy; -import org.testng.Assert; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; /* * @test * @bug 8285401 * @summary Avoid initialization of parameter types in proxy construction - * @run testng LazyInitializationTest + * @run junit LazyInitializationTest */ public final class LazyInitializationTest { private static volatile boolean initialized = false; @@ -50,9 +51,9 @@ public final class LazyInitializationTest { Intf value = (Intf) Proxy.newProxyInstance(LazyInitializationTest.class.getClassLoader(), new Class[]{ Intf.class }, (proxy, method, args) -> null); - Assert.assertFalse(initialized, "parameter type initialized unnecessarily"); + assertFalse(initialized, "parameter type initialized unnecessarily"); value.m(new Parameter()); - Assert.assertTrue(initialized, "parameter type initialized after instantiation"); + assertTrue(initialized, "parameter type initialized after instantiation"); } } diff --git a/test/jdk/java/lang/reflect/Proxy/ProxyClassAccessTest.java b/test/jdk/java/lang/reflect/Proxy/ProxyClassAccessTest.java index 50fbd150ec7..265f9ce7104 100644 --- a/test/jdk/java/lang/reflect/Proxy/ProxyClassAccessTest.java +++ b/test/jdk/java/lang/reflect/Proxy/ProxyClassAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -32,17 +32,17 @@ import java.util.List; import jdk.test.lib.compiler.CompilerUtils; import static jdk.test.lib.process.ProcessTools.executeTestJava; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; -/** +/* * @test * @library /test/lib * @modules jdk.compiler * @build ProxyClassAccessTest q.NP * jdk.test.lib.compiler.CompilerUtils - * @run testng ProxyClassAccessTest + * @run junit ProxyClassAccessTest * @summary Driver for testing proxy class doesn't have access to * types referenced by proxy interfaces */ @@ -61,8 +61,8 @@ public class ProxyClassAccessTest { /** * Compiles all modules used by the test */ - @BeforeTest - public void compileAll() throws Exception { + @BeforeAll + public static void compileAll() throws Exception { for (String mn : modules) { Path msrc = SRC_DIR.resolve(mn); assertTrue(CompilerUtils.compile(msrc, MODS_DIR, "--module-source-path", SRC_DIR.toString())); @@ -80,7 +80,7 @@ public class ProxyClassAccessTest { .errorTo(System.out) .getExitValue(); - assertTrue(exitValue == 0); + assertEquals(0, exitValue); } /** @@ -105,16 +105,10 @@ public class ProxyClassAccessTest { } private void checkIAE(ClassLoader loader, Class[] interfaces) throws Throwable { - try { - Proxy.getProxyClass(loader, interfaces); - throw new RuntimeException("Expected IllegalArgumentException thrown"); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> Proxy.getProxyClass(loader, interfaces)); - try { - Proxy.newProxyInstance(loader, interfaces, - (proxy, m, params) -> { throw new RuntimeException(m.toString()); }); - throw new RuntimeException("Expected IllegalArgumentException thrown"); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> Proxy.newProxyInstance(loader, interfaces, + (proxy, m, params) -> { throw new RuntimeException(m.toString()); })); } } diff --git a/test/jdk/java/lang/reflect/Proxy/ProxyLayerTest.java b/test/jdk/java/lang/reflect/Proxy/ProxyLayerTest.java index 85ebf922a20..d2708e18c0e 100644 --- a/test/jdk/java/lang/reflect/Proxy/ProxyLayerTest.java +++ b/test/jdk/java/lang/reflect/Proxy/ProxyLayerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -32,17 +32,18 @@ import java.util.Arrays; import jdk.test.lib.compiler.CompilerUtils; import static jdk.test.lib.process.ProcessTools.executeTestJava; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; -/** +/* * @test * @library /test/lib * @modules jdk.compiler * @build ProxyTest jdk.test.lib.process.ProcessTools * jdk.test.lib.compiler.CompilerUtils - * @run testng ProxyLayerTest + * @run junit ProxyLayerTest * @summary Test proxies to implement interfaces in a layer */ @@ -62,8 +63,8 @@ public class ProxyLayerTest { /** * Compiles all modules used by the test */ - @BeforeTest - public void compileAll() throws Exception { + @BeforeAll + public static void compileAll() throws Exception { for (String mn : modules) { Path msrc = SRC_DIR.resolve(mn); assertTrue(CompilerUtils.compile(msrc, MODS_DIR, "--module-source-path", SRC_DIR.toString())); @@ -102,7 +103,7 @@ public class ProxyLayerTest { assertTrue(proxyClass.getModule().isNamed()); assertTrue(pkg.isSealed()); assertTrue(proxyClass.getModule().isExported(pkg.getName())); - assertEquals(proxyClass.getModule().getLayer(), null); + assertNull(proxyClass.getModule().getLayer()); } /** @@ -134,7 +135,7 @@ public class ProxyLayerTest { assertTrue(proxyClass.getModule().isNamed()); assertTrue(pkg.isSealed()); assertFalse(proxyClass.getModule().isExported(pkg.getName())); - assertEquals(proxyClass.getModule().getLayer(), null); + assertNull(proxyClass.getModule().getLayer()); } /** @@ -164,15 +165,8 @@ public class ProxyLayerTest { } private void checkIAE(ClassLoader loader, Class[] interfaces) { - try { - Proxy.getProxyClass(loader, interfaces); - throw new RuntimeException("Expected IllegalArgumentException thrown"); - } catch (IllegalArgumentException e) {} - - try { - Proxy.newProxyInstance(loader, interfaces, handler); - throw new RuntimeException("Expected IllegalArgumentException thrown"); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> Proxy.getProxyClass(loader, interfaces)); + assertThrows(IllegalArgumentException.class, () -> Proxy.newProxyInstance(loader, interfaces, handler)); } private final static InvocationHandler handler = diff --git a/test/jdk/java/lang/reflect/Proxy/ProxyTest.java b/test/jdk/java/lang/reflect/Proxy/ProxyTest.java index 811471585a9..1da6a10260a 100644 --- a/test/jdk/java/lang/reflect/Proxy/ProxyTest.java +++ b/test/jdk/java/lang/reflect/Proxy/ProxyTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, 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 @@ -29,17 +29,17 @@ import java.util.List; import jdk.test.lib.compiler.CompilerUtils; import static jdk.test.lib.process.ProcessTools.executeTestJava; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; -/** +/* * @test * @library /test/lib * @modules jdk.compiler * @build ProxyTest q.U * jdk.test.lib.compiler.CompilerUtils - * @run testng ProxyTest + * @run junit ProxyTest * @summary Driver for testing proxies accessing interfaces in named modules */ @@ -59,8 +59,8 @@ public class ProxyTest { /** * Compiles all modules used by the test */ - @BeforeTest - public void compileAll() throws Exception { + @BeforeAll + public static void compileAll() throws Exception { for (String mn : modules) { Path msrc = SRC_DIR.resolve(mn); assertTrue(CompilerUtils.compile(msrc, MODS_DIR, "--module-source-path", SRC_DIR.toString())); @@ -79,7 +79,7 @@ public class ProxyTest { .errorTo(System.out) .getExitValue(); - assertTrue(exitValue == 0); + assertEquals(0, exitValue); } /** @@ -95,6 +95,6 @@ public class ProxyTest { .errorTo(System.out) .getExitValue(); - assertTrue(exitValue == 0); + assertEquals(0, exitValue); } } diff --git a/test/jdk/java/lang/reflect/Proxy/SealedInterfaceTest.java b/test/jdk/java/lang/reflect/Proxy/SealedInterfaceTest.java index 1337248f817..822c5d83319 100644 --- a/test/jdk/java/lang/reflect/Proxy/SealedInterfaceTest.java +++ b/test/jdk/java/lang/reflect/Proxy/SealedInterfaceTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -24,15 +24,15 @@ /* * @test * @bug 8269351 - * @run testng SealedInterfaceTest + * @run junit SealedInterfaceTest */ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class SealedInterfaceTest { sealed interface Intf permits NonSealedInterface { @@ -43,16 +43,17 @@ public class SealedInterfaceTest { void m2(); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testSealedInterface() { - Proxy.newProxyInstance(SealedInterfaceTest.class.getClassLoader(), + assertThrows(IllegalArgumentException.class, () -> Proxy.newProxyInstance( + SealedInterfaceTest.class.getClassLoader(), new Class[]{ Intf.class }, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } - }); + })); } @Test diff --git a/test/jdk/java/lang/reflect/Proxy/TestVarArgs.java b/test/jdk/java/lang/reflect/Proxy/TestVarArgs.java index a472f75d4b7..b16831c7867 100644 --- a/test/jdk/java/lang/reflect/Proxy/TestVarArgs.java +++ b/test/jdk/java/lang/reflect/Proxy/TestVarArgs.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -21,10 +21,10 @@ * questions. */ -/** +/* * @test * @bug 8022795 - * @run testng TestVarArgs + * @run junit TestVarArgs * @summary Verify if a method defined in a proxy interface has ACC_VARARGS set */ @@ -34,11 +34,10 @@ import java.lang.invoke.MethodType; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; -import java.util.Arrays; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestVarArgs { interface I { @@ -48,8 +47,7 @@ public class TestVarArgs { Object call(Object[] values); } - @DataProvider(name = "proxyInterfaces") - public Object[][] proxyInterfaces() { + public static Object[][] proxyInterfaces() { return new Object[][] { { new Class[] { I.class }, true}, { new Class[] { J.class }, false}, @@ -58,11 +56,12 @@ public class TestVarArgs { }; } - @Test(dataProvider = "proxyInterfaces") + @ParameterizedTest + @MethodSource("proxyInterfaces") public void testMethod(Class[] proxyInterfaces, boolean isVarArgs) throws Throwable { // check if the first proxy interface with the method named "call" declares var result Method m = proxyInterfaces[0].getMethod("call", Object[].class); - assertTrue(m.isVarArgs() == isVarArgs); + assertEquals(isVarArgs, m.isVarArgs()); // the method in the generated proxy class should match the method // declared in the proxy interface @@ -71,19 +70,19 @@ public class TestVarArgs { Class proxyClass = proxy.getClass(); assertTrue(Proxy.isProxyClass(proxyClass)); Method method = proxyClass.getMethod("call", Object[].class); - assertTrue(method.isVarArgs() == isVarArgs); + assertEquals(isVarArgs, method.isVarArgs()); - Object params = new Object[] { "foo", "bar", "goo" }; - Object result; + Object[] params = new Object[] { "foo", "bar", "goo" }; + Object[] result; // test reflection - result = method.invoke(proxy, params); - assertEquals(result, params); + result = (Object[]) method.invoke(proxy, new Object[] {params}); + assertEquals(params, result); // test method handle MethodHandle mh = MethodHandles.lookup().findVirtual(proxyClass, "call", MethodType.methodType(Object.class, Object[].class)); - assertTrue(mh.isVarargsCollector() == isVarArgs); + assertEquals(isVarArgs, mh.isVarargsCollector()); MethodHandle mhVarArity = mh; MethodHandle mhFixedArity = mh; if (isVarArgs) { @@ -91,18 +90,18 @@ public class TestVarArgs { } else { mhVarArity = mh.asVarargsCollector(Object[].class); } - result = mhVarArity.invoke(proxy, "foo", "bar", "goo"); - assertEquals(result, params); + result = (Object[]) mhVarArity.invoke(proxy, "foo", "bar", "goo"); + assertArrayEquals(params, result); - result = mhFixedArity.invoke(proxy, params); - assertEquals(result, params); + result = (Object[]) mhFixedArity.invoke(proxy, params); + assertArrayEquals(params, result); if (!isVarArgs) { MethodType mt = MethodType.methodType(Object.class, Object.class, String.class, String.class, String.class); mh = mh.asVarargsCollector(Object[].class).asType(mt); } - result = mh.invoke(proxy, "foo", "bar", "goo"); - assertEquals(result, params); + result = (Object[]) mh.invoke(proxy, "foo", "bar", "goo"); + assertArrayEquals(params, result); } private static final InvocationHandler IH = new InvocationHandler() { diff --git a/test/jdk/java/lang/reflect/Proxy/nonPublicProxy/DefaultMethodProxy.java b/test/jdk/java/lang/reflect/Proxy/nonPublicProxy/DefaultMethodProxy.java index daf6f656aab..a304063638c 100644 --- a/test/jdk/java/lang/reflect/Proxy/nonPublicProxy/DefaultMethodProxy.java +++ b/test/jdk/java/lang/reflect/Proxy/nonPublicProxy/DefaultMethodProxy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -25,16 +25,17 @@ import java.lang.reflect.*; import java.util.Arrays; import java.util.stream.Collectors; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test * @bug 8159746 * @summary Test invoking a default method in a non-public proxy interface * @build p.Foo p.Bar p.ProxyMaker - * @run testng DefaultMethodProxy + * @run junit DefaultMethodProxy */ public class DefaultMethodProxy { public interface I { @@ -42,7 +43,7 @@ public class DefaultMethodProxy { } @Test - public static void publicInterface() throws ReflectiveOperationException { + public void publicInterface() throws ReflectiveOperationException { // create a proxy instance of a public proxy interface should succeed Proxy proxy = (Proxy)Proxy.newProxyInstance(DefaultMethodProxy.class.getClassLoader(), new Class[] { I.class }, IH); @@ -50,11 +51,9 @@ public class DefaultMethodProxy { testDefaultMethod(proxy, "I"); // can get the invocation handler - assertTrue(Proxy.getInvocationHandler(proxy) == IH); + assertSame(IH, Proxy.getInvocationHandler(proxy)); } - - @DataProvider(name = "nonPublicIntfs") private static Object[][] nonPublicIntfs() throws ClassNotFoundException { Class fooClass = Class.forName("p.Foo"); Class barClass = Class.forName("p.Bar"); @@ -65,8 +64,9 @@ public class DefaultMethodProxy { }; } - @Test(dataProvider = "nonPublicIntfs") - public static void hasPackageAccess(Class[] intfs, String expected) throws ReflectiveOperationException { + @ParameterizedTest + @MethodSource("nonPublicIntfs") + public void hasPackageAccess(Class[] intfs, String expected) throws ReflectiveOperationException { Proxy proxy = (Proxy)Proxy.newProxyInstance(DefaultMethodProxy.class.getClassLoader(), intfs, IH); testDefaultMethod(proxy, expected); @@ -75,19 +75,13 @@ public class DefaultMethodProxy { } // IAE thrown at invocation time - @Test(dataProvider = "nonPublicIntfs", expectedExceptions = {IllegalAccessException.class}) - public static void noPackageAccess(Class[] intfs, String ignored) throws Throwable { + @ParameterizedTest + @MethodSource("nonPublicIntfs") + public void noPackageAccess(Class[] intfs, String ignored) throws Throwable { Proxy proxy = (Proxy)Proxy.newProxyInstance(DefaultMethodProxy.class.getClassLoader(), intfs, IH_NO_ACCESS); - try { - testDefaultMethod(proxy, "dummy"); - } catch (InvocationTargetException e) { - // unwrap the exception - if (e.getCause() instanceof UndeclaredThrowableException) { - Throwable cause = e.getCause(); - throw cause.getCause(); - } - throw e; - } + InvocationTargetException ite = assertThrows(InvocationTargetException.class, () -> testDefaultMethod(proxy, "dummy")); + var ute = assertInstanceOf(UndeclaredThrowableException.class, ite.getCause(), "unwrap the InvocationTargetException"); + assertInstanceOf(IllegalAccessException.class, ute.getCause(), "unwrap the UndeclaredThrowableException"); } /* diff --git a/test/jdk/java/lang/reflect/annotationSharing/AnnotationSharing.java b/test/jdk/java/lang/reflect/annotationSharing/AnnotationSharing.java index 98a13d6416c..b29c74637d6 100644 --- a/test/jdk/java/lang/reflect/annotationSharing/AnnotationSharing.java +++ b/test/jdk/java/lang/reflect/annotationSharing/AnnotationSharing.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2026, 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 @@ -27,13 +27,13 @@ * @summary Test sharing of annotations between Executable/Field instances. * Sharing should not be noticeable when performing mutating * operations. - * @run testng AnnotationSharing + * @run junit AnnotationSharing */ import java.lang.annotation.*; import java.lang.reflect.*; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; public class AnnotationSharing { @Test diff --git a/test/jdk/java/lang/reflect/callerCache/CustomLoaderTest.java b/test/jdk/java/lang/reflect/callerCache/CustomLoaderTest.java index f3a429027d9..6951cc0829c 100644 --- a/test/jdk/java/lang/reflect/callerCache/CustomLoaderTest.java +++ b/test/jdk/java/lang/reflect/callerCache/CustomLoaderTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, 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 @@ -27,7 +27,7 @@ * @library /test/lib/ * @modules jdk.compiler * @build CustomLoaderTest jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm CustomLoaderTest + * @run junit/othervm CustomLoaderTest * * @summary Test method whose parameter types and return type are not visible to the caller. */ @@ -42,27 +42,23 @@ import java.nio.file.Paths; import java.util.concurrent.atomic.AtomicInteger; import jdk.test.lib.compiler.CompilerUtils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class CustomLoaderTest { private static final Path CLASSES = Paths.get("classes"); - @BeforeTest - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { String src = System.getProperty("test.src", "."); String classpath = System.getProperty("test.classes", "."); boolean rc = CompilerUtils.compile(Paths.get(src, "ReflectTest.java"), CLASSES, "-cp", classpath); if (!rc) { - throw new RuntimeException("fail compilation"); - } - try { - Class p = Class.forName("ReflectTest$P"); - fail("should not be visible to this loader"); - } catch (ClassNotFoundException e) { - e.printStackTrace(); + fail("fail compilation"); } + assertThrows(ClassNotFoundException.class, () -> Class.forName("ReflectTest$P"), + "should not be visible to this loader"); } @Test @@ -72,17 +68,17 @@ public class CustomLoaderTest { Method m1 = loader1.findMethod(); Method m2 = loader2.findMethod(); - assertTrue(m1.getDeclaringClass() != m2.getDeclaringClass()); + assertNotSame(m1.getDeclaringClass(), m2.getDeclaringClass()); - assertTrue(m1.getDeclaringClass() == loader1.c); - assertTrue(m2.getDeclaringClass() == loader2.c); + assertSame(loader1.c, m1.getDeclaringClass()); + assertSame(loader2.c, m2.getDeclaringClass()); Object o1 = m1.invoke(loader1.c.newInstance(), loader1.p.newInstance(), loader1.q.newInstance()); Object o2 = m2.invoke(loader2.c.newInstance(), loader2.p.newInstance(), loader2.q.newInstance()); - assertTrue(o1.getClass() != o2.getClass()); - assertTrue(o1.getClass() == loader1.r); - assertTrue(o2.getClass() == loader2.r); + assertNotSame(o1.getClass(), o2.getClass()); + assertSame(loader1.r, o1.getClass()); + assertSame(loader2.r, o2.getClass()); } static class TestLoader extends URLClassLoader { diff --git a/test/jdk/java/lang/reflect/callerCache/ReflectionCallerCacheTest.java b/test/jdk/java/lang/reflect/callerCache/ReflectionCallerCacheTest.java index b640a5e2150..4513c698a54 100644 --- a/test/jdk/java/lang/reflect/callerCache/ReflectionCallerCacheTest.java +++ b/test/jdk/java/lang/reflect/callerCache/ReflectionCallerCacheTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, 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 @@ -29,7 +29,7 @@ * @library /test/lib/ * @modules jdk.compiler * @build ReflectionCallerCacheTest Members jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm ReflectionCallerCacheTest + * @run junit/othervm ReflectionCallerCacheTest */ import java.io.IOException; @@ -44,16 +44,16 @@ import java.util.concurrent.Callable; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.util.ForceGC; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ReflectionCallerCacheTest { private static final Path CLASSES = Paths.get("classes"); private static final ReflectionCallerCacheTest TEST = new ReflectionCallerCacheTest(); - @BeforeTest - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { String src = System.getProperty("test.src", "."); String classpath = System.getProperty("test.classes", "."); boolean rc = CompilerUtils.compile(Paths.get(src, "AccessTest.java"), CLASSES, "-cp", classpath); @@ -61,8 +61,8 @@ public class ReflectionCallerCacheTest { throw new RuntimeException("fail compilation"); } } - @DataProvider(name = "memberAccess") - public Object[][] memberAccess() { + + public static Object[][] memberAccess() { return new Object[][] { { "AccessTest$PublicConstructor" }, { "AccessTest$PublicMethod" }, @@ -102,8 +102,9 @@ public class ReflectionCallerCacheTest { } } - @Test(dataProvider = "memberAccess") - private void load(String classname) throws Exception { + @ParameterizedTest + @MethodSource("memberAccess") + void load(String classname) throws Exception { WeakReference weakLoader = loadAndRunClass(classname); // Force garbage collection to trigger unloading of class loader diff --git a/test/jdk/java/lang/reflect/records/CheckEqualityIsBasedOnFields.java b/test/jdk/java/lang/reflect/records/CheckEqualityIsBasedOnFields.java index b5c438e4f9a..c3e4431bd84 100644 --- a/test/jdk/java/lang/reflect/records/CheckEqualityIsBasedOnFields.java +++ b/test/jdk/java/lang/reflect/records/CheckEqualityIsBasedOnFields.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -25,17 +25,15 @@ * @test * @bug 8257598 * @summary check that Record::equals uses the fields and not the accessors for the comparison - * @run testng CheckEqualityIsBasedOnFields + * @run junit CheckEqualityIsBasedOnFields */ import java.lang.reflect.Constructor; -import java.lang.reflect.Field; import java.lang.reflect.Method; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class CheckEqualityIsBasedOnFields { public record R01(boolean x) { @@ -91,8 +89,7 @@ public class CheckEqualityIsBasedOnFields { } } - @DataProvider(name = "recordData") - public Object[][] recordTypeAndExpectedValue() { + public static Object[][] recordTypeAndExpectedValue() { return new Object[][] { new Object[] { R01.class, boolean.class, new Object[]{true, false} }, new Object[] { R02.class, byte.class, new Object[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)5, @@ -112,7 +109,8 @@ public class CheckEqualityIsBasedOnFields { }; } - @Test(dataProvider = "recordData") + @ParameterizedTest + @MethodSource("recordTypeAndExpectedValue") public void testEqualsDoesntUseAccessors(Class clazz, Class componentClass, Object[] expectedXValues) throws Exception { Constructor ctor; Method getter, equalsMethod; @@ -125,8 +123,8 @@ public class CheckEqualityIsBasedOnFields { System.out.println(rec1.toString()); System.out.println(rec2.toString()); assertFalse((boolean) equalsMethod.invoke(rec1, rec2)); - assertNotEquals(expectedXValues[i], expectedXValues[i + expectedXValues.length / 2]); - assertEquals(getter.invoke(rec1), getter.invoke(rec2)); + assertNotEquals(expectedXValues[i + expectedXValues.length / 2], expectedXValues[i]); + assertEquals(getter.invoke(rec2), getter.invoke(rec1)); } } } diff --git a/test/jdk/java/lang/reflect/records/IsRecordTest.java b/test/jdk/java/lang/reflect/records/IsRecordTest.java index 4888e6d506e..153329a7832 100644 --- a/test/jdk/java/lang/reflect/records/IsRecordTest.java +++ b/test/jdk/java/lang/reflect/records/IsRecordTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -26,32 +26,31 @@ * @bug 8255560 * @summary Class::isRecord should check that the current class is final and not abstract * @library /test/lib - * @run testng/othervm IsRecordTest + * @run junit/othervm IsRecordTest */ import java.lang.classfile.ClassFile; import java.lang.constant.ClassDesc; -import java.lang.reflect.AccessFlag; import java.util.List; import java.util.Map; import java.lang.classfile.attribute.RecordAttribute; import java.lang.classfile.attribute.RecordComponentInfo; import jdk.test.lib.ByteCodeLoader; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.System.out; import static java.lang.classfile.ClassFile.ACC_ABSTRACT; import static java.lang.classfile.ClassFile.ACC_FINAL; import static java.lang.constant.ConstantDescs.CD_int; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; public class IsRecordTest { - @DataProvider(name = "scenarios") - public Object[][] scenarios() { + public static Object[][] scenarios() { return new Object[][] { // isFinal, isAbstract, extendJLR, withRecAttr, expectIsRecord { false, false, false, true, false }, @@ -75,7 +74,8 @@ public class IsRecordTest { * iii) direct subclass of j.l.Record (or not), along with the presence or * absence of a record attribute. */ - @Test(dataProvider = "scenarios") + @ParameterizedTest + @MethodSource("scenarios") public void testDirectSubClass(boolean isFinal, boolean isAbstract, boolean extendsJLR, @@ -92,9 +92,8 @@ public class IsRecordTest { Class cls = ByteCodeLoader.load("C", classBytes); out.println("cls=%s, Record::isAssignable=%s, isRecord=%s" .formatted(cls, Record.class.isAssignableFrom(cls), cls.isRecord())); - assertEquals(cls.isRecord(), expectIsRecord); - var getRecordComponents = cls.getRecordComponents(); - assertTrue(expectIsRecord ? getRecordComponents != null : getRecordComponents == null); + assertEquals(expectIsRecord, cls.isRecord()); + assertEquals(expectIsRecord, cls.getRecordComponents() != null); } /** @@ -102,7 +101,8 @@ public class IsRecordTest { * along with the presence or absence of a record attribute, where the class has * a superclass whose superclass is j.l.Record. */ - @Test(dataProvider = "scenarios") + @ParameterizedTest + @MethodSource("scenarios") public void testIndirectSubClass(boolean isFinal, boolean isAbstract, boolean unused1, @@ -127,8 +127,8 @@ public class IsRecordTest { .formatted(cls, Record.class.isAssignableFrom(cls), cls.isRecord())); assertFalse(supFooCls.isRecord()); assertFalse(subFooCls.isRecord()); - assertEquals(supFooCls.getRecordComponents(), null); - assertEquals(subFooCls.getRecordComponents(), null); + assertNull(supFooCls.getRecordComponents()); + assertNull(subFooCls.getRecordComponents()); } /** Tests record-ness properties of traditionally compiled classes. */ @@ -137,23 +137,23 @@ public class IsRecordTest { out.println("\n--- testBasicRecords ---"); record EmptyRecord () { } assertTrue(EmptyRecord.class.isRecord()); - assertEquals(EmptyRecord.class.getRecordComponents().length, 0); + assertEquals(0, EmptyRecord.class.getRecordComponents().length); record FooRecord (int x) { } assertTrue(FooRecord.class.isRecord()); - assertTrue(FooRecord.class.getRecordComponents() != null); + assertNotNull(FooRecord.class.getRecordComponents()); final record FinalFooRecord (int x) { } assertTrue(FinalFooRecord.class.isRecord()); - assertTrue(FinalFooRecord.class.getRecordComponents() != null); + assertNotNull(FinalFooRecord.class.getRecordComponents()); class A { } assertFalse(A.class.isRecord()); - assertFalse(A.class.getRecordComponents() != null); + assertNull(A.class.getRecordComponents()); final class B { } assertFalse(B.class.isRecord()); - assertFalse(B.class.getRecordComponents() != null); + assertNull(B.class.getRecordComponents()); } // -- infra diff --git a/test/jdk/java/lang/reflect/records/RecordReflectionTest.java b/test/jdk/java/lang/reflect/records/RecordReflectionTest.java index 0598e88f0c1..5cc2fd4f8eb 100644 --- a/test/jdk/java/lang/reflect/records/RecordReflectionTest.java +++ b/test/jdk/java/lang/reflect/records/RecordReflectionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, 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 @@ -27,16 +27,17 @@ * @summary reflection test for records * @build R10 * @compile RecordReflectionTest.java - * @run testng/othervm RecordReflectionTest + * @run junit/othervm RecordReflectionTest */ import java.lang.annotation.*; import java.lang.reflect.*; import java.util.List; -import org.testng.annotations.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@Test public class RecordReflectionTest { class NoRecord {} @@ -78,8 +79,7 @@ public class RecordReflectionTest { R13 {} // compact constructor, will contain mandated parameters } - @DataProvider(name = "recordClasses") - public Object[][] recordClassData() { + public static Object[][] recordClassData() { return List.of(R1.class, R2.class, R3.class, @@ -96,17 +96,17 @@ public class RecordReflectionTest { ).stream().map(c -> new Object[] {c}).toArray(Object[][]::new); } - @Test(dataProvider = "recordClasses") + @ParameterizedTest + @MethodSource("recordClassData") public void testIsRecord(Class cls) { String message = cls.toGenericString(); assertTrue(cls.isRecord()); - assertTrue(cls.getSuperclass() == java.lang.Record.class); - assertTrue(cls.getRecordComponents() != null); + assertSame(Record.class, cls.getSuperclass()); + assertNotNull(cls.getRecordComponents()); assertTrue(message.contains("record"), message); } - @DataProvider(name = "notRecordClasses") - public Object[][] notRecordClasses() { + public static List> notRecordClasses() { return List.of(NoRecord.class, NoRecord[].class, Record.class, // java.lang.Record is not itself a record class @@ -116,19 +116,18 @@ public class RecordReflectionTest { int.class, int[].class, long.class, - long[].class) - .stream().map(c -> new Object[] {c}).toArray(Object[][]::new); + long[].class); } - @Test(dataProvider = "notRecordClasses") + @ParameterizedTest + @MethodSource("notRecordClasses") public void testNotARecordClass(Class cls) { assertFalse(cls.isRecord()); - assertFalse(cls.getSuperclass() == java.lang.Record.class); - assertTrue(cls.getRecordComponents() == null); + assertNotSame(Record.class, cls.getSuperclass()); + assertNull(cls.getRecordComponents()); } - @DataProvider(name = "reflectionData") - public Object[][] reflectionData() { + public static Object[][] reflectionData() { return new Object[][] { new Object[] { new R1(), 0, @@ -181,7 +180,8 @@ public class RecordReflectionTest { }; } - @Test(dataProvider = "reflectionData") + @ParameterizedTest + @MethodSource("reflectionData") public void testRecordReflection(Object recordOb, int numberOfComponents, Object[] values, @@ -192,13 +192,13 @@ public class RecordReflectionTest { Class recordClass = recordOb.getClass(); assertTrue(recordClass.isRecord()); RecordComponent[] recordComponents = recordClass.getRecordComponents(); - assertEquals(recordComponents.length, numberOfComponents); + assertEquals(numberOfComponents, recordComponents.length); int i = 0; for (RecordComponent rc : recordComponents) { - assertEquals(rc.getName(), names[i]); - assertEquals(rc.getType(), rc.getAccessor().getReturnType()); - assertEquals(rc.getAccessor().invoke(recordOb), values[i]); - assertEquals(rc.getAccessor().getGenericReturnType().toString(), signatures[i], + assertEquals(names[i], rc.getName()); + assertEquals(rc.getAccessor().getReturnType(), rc.getType()); + assertEquals(values[i], rc.getAccessor().invoke(recordOb)); + assertEquals(signatures[i], rc.getAccessor().getGenericReturnType().toString(), String.format("signature of method \"%s\" different from expected signature \"%s\"", rc.getAccessor().getGenericReturnType(), signatures[i])); i++; @@ -207,7 +207,7 @@ public class RecordReflectionTest { var constructor = recordClass.getDeclaredConstructors()[0]; i = 0; for (var p: constructor.getParameters()) { - assertEquals(p.getParameterizedType().toString(), signatures[i], + assertEquals(signatures[i], p.getParameterizedType().toString(), String.format("signature of method \"%s\" different from expected signature \"%s\"", p.getType().toString(), signatures[i])); i++; @@ -215,7 +215,7 @@ public class RecordReflectionTest { // similar as above but testing another API i = 0; for (var p : constructor.getGenericParameterTypes()) { - assertEquals(p.toString(), signatures[i], + assertEquals(signatures[i], p.toString(), String.format("signature of method \"%s\" different from expected signature \"%s\"", p.toString(), signatures[i])); i++; @@ -228,16 +228,17 @@ public class RecordReflectionTest { record AnnotatedRec(@RCA int i) {} + @Test public void testDeclAnnotationsInRecordComp() throws Throwable { Class recordClass = AnnotatedRec.class; RecordComponent rc = recordClass.getRecordComponents()[0]; Annotation[] annos = rc.getAnnotations(); - assertEquals(annos.length, 1); - assertEquals(annos[0].toString(), "@RecordReflectionTest.RCA()"); + assertEquals(1, annos.length); + assertEquals("@RecordReflectionTest.RCA()", annos[0].toString()); Field f = recordClass.getDeclaredField("i"); - assertEquals(f.getAnnotations().length, 1); - assertEquals(f.getAnnotations()[0].toString(), annos[0].toString()); + assertEquals(1, f.getAnnotations().length); + assertEquals(annos[0].toString(), f.getAnnotations()[0].toString()); } @Retention(RetentionPolicy.RUNTIME) @@ -246,30 +247,28 @@ public class RecordReflectionTest { record TypeAnnotatedRec(@TYPE_USE int i) {} + @Test public void testTypeAnnotationsInRecordComp() throws Throwable { Class recordClass = TypeAnnotatedRec.class; RecordComponent rc = recordClass.getRecordComponents()[0]; AnnotatedType at = rc.getAnnotatedType(); Annotation[] annos = at.getAnnotations(); - assertEquals(annos.length, 1); - assertEquals(annos[0].toString(), "@RecordReflectionTest.TYPE_USE()"); + assertEquals(1, annos.length); + assertEquals("@RecordReflectionTest.TYPE_USE()", annos[0].toString()); Field f = recordClass.getDeclaredField("i"); - assertEquals(f.getAnnotatedType().getAnnotations().length, 1); - assertEquals(f.getAnnotatedType().getAnnotations()[0].toString(), annos[0].toString()); + assertEquals(1, f.getAnnotatedType().getAnnotations().length); + assertEquals(annos[0].toString(), f.getAnnotatedType().getAnnotations()[0].toString()); } + @Test public void testReadOnlyFieldInRecord() throws Throwable { R2 o = new R2(1, 2); Class recordClass = R2.class; String fieldName = "i"; Field f = recordClass.getDeclaredField(fieldName); assertTrue(f.trySetAccessible()); - assertTrue(f.get(o) != null); - try { - f.set(o, null); - assertTrue(false, "should fail to set " + fieldName); - } catch (IllegalAccessException e) { - } + assertNotNull(f.get(o)); + assertThrows(IllegalAccessException.class, () -> f.set(o, null)); } } diff --git a/test/jdk/java/lang/reflect/sealed_classes/SealedClassesReflectionTest.java b/test/jdk/java/lang/reflect/sealed_classes/SealedClassesReflectionTest.java index 03caebb49e8..6e14a5d540e 100644 --- a/test/jdk/java/lang/reflect/sealed_classes/SealedClassesReflectionTest.java +++ b/test/jdk/java/lang/reflect/sealed_classes/SealedClassesReflectionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, 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 @@ -26,18 +26,17 @@ * @bug 8227046 * @summary reflection test for sealed classes * @compile SealedClassesReflectionTest.java - * @run testng/othervm SealedClassesReflectionTest + * @run junit/othervm SealedClassesReflectionTest */ import java.lang.annotation.*; -import java.lang.constant.ClassDesc; import java.lang.reflect.*; import java.util.Arrays; import java.util.List; -import org.testng.annotations.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@Test public class SealedClassesReflectionTest { sealed class SealedClass1 permits FinalSubclass1, NonSealedSubclass1 {} @@ -68,8 +67,7 @@ public class SealedClassesReflectionTest { sealed class SealedSubclass2 implements SealedInt3 permits NonSealedSubclass2 {} non-sealed class NonSealedSubclass2 extends SealedSubclass2 {} - @DataProvider(name = "sealedClasses") - public Object[][] sealedClassesData() { + public static List> sealedClassesData() { return List.of( SealedClass1.class, SealedClass2.class, @@ -79,19 +77,19 @@ public class SealedClassesReflectionTest { SealedInt2.class, SealedInt3.class, SealedSubInt1.class - ).stream().map(c -> new Object[] {c}).toArray(Object[][]::new); + ); } - @Test(dataProvider = "sealedClasses") + @ParameterizedTest + @MethodSource("sealedClassesData") public void testSealedClasses(Class cls) { assertTrue(cls.isSealed()); - assertTrue(!Modifier.isFinal(cls.getModifiers())); - assertTrue(cls.getPermittedSubclasses() != null); + assertFalse(Modifier.isFinal(cls.getModifiers())); + assertNotNull(cls.getPermittedSubclasses()); assertTrue(cls.getPermittedSubclasses().length > 0); } - @DataProvider(name = "notSealedClasses") - public Object[][] notSealedClassesData() { + public static List> notSealedClassesData() { return List.of( Object.class, void.class, Void.class, Void[].class, @@ -104,34 +102,34 @@ public class SealedClassesReflectionTest { double.class, double[].class, Double.class, Double[].class, boolean.class, boolean[].class, Boolean.class, Boolean[].class, String.class, String[].class - ).stream().map(c -> new Object[] {c}).toArray(Object[][]::new); + ); } - @Test(dataProvider = "notSealedClasses") + @ParameterizedTest + @MethodSource("notSealedClassesData") public void testNotSealedClasses(Class cls) { - assertTrue(!cls.isSealed()); - assertTrue(cls.getPermittedSubclasses() == null); + assertFalse(cls.isSealed()); + assertNull(cls.getPermittedSubclasses()); } - @DataProvider(name = "non_sealedClasses") - public Object[][] non_sealedClassesData() { + public static List> non_sealedClassesData() { return List.of( NonSealedSubclass1.class, NonSealedSubInt1.class, NonSealedSubclass2.class - ).stream().map(c -> new Object[] {c}).toArray(Object[][]::new); + ); } - @Test(dataProvider = "non_sealedClasses") + @ParameterizedTest + @MethodSource("non_sealedClassesData") public void testnon_sealedClasses(Class cls) { - assertTrue(!cls.isSealed()); - assertTrue(!Modifier.isFinal(cls.getModifiers())); + assertFalse(cls.isSealed()); + assertFalse(Modifier.isFinal(cls.getModifiers())); assertTrue((cls.getSuperclass() != null && cls.getSuperclass().isSealed()) || Arrays.stream(cls.getInterfaces()).anyMatch(Class::isSealed)); - assertTrue(cls.getPermittedSubclasses() == null); + assertNull(cls.getPermittedSubclasses()); } - @DataProvider(name = "reflectionData") - public Object[][] reflectionData() { + public static Object[][] reflectionData() { return new Object[][] { new Object[] { SealedClass1.class, @@ -204,7 +202,8 @@ public class SealedClassesReflectionTest { SEALED, NON_SEALED, FINAL } - @Test(dataProvider = "reflectionData") + @ParameterizedTest + @MethodSource("reflectionData") public void testSealedReflection(Class sealedClass, int numberOfSubclasses, String[] subclassDescriptors, @@ -213,10 +212,10 @@ public class SealedClassesReflectionTest { throws ReflectiveOperationException { assertTrue(sealedClass.isSealed()); - assertTrue(sealedClass.getPermittedSubclasses().length == numberOfSubclasses); + assertEquals(numberOfSubclasses, sealedClass.getPermittedSubclasses().length); int i = 0; for (Class cd : sealedClass.getPermittedSubclasses()) { - assertTrue(cd.getName().equals(subclassDescriptors[i]), "expected: " + subclassDescriptors[i] + " found: " + cd.getName()); + assertEquals(subclassDescriptors[i], cd.getName()); i++; } i = 0; From a5d0b05136e34871366441a8c8e6bda5f20c617c Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Tue, 27 Jan 2026 15:04:26 +0000 Subject: [PATCH 080/105] 8376274: JSpec preview support and output enhancement Reviewed-by: hannesw --- .../src/classes/build/tools/taglet/JSpec.java | 69 ++++++++++++++++--- .../lang/runtime/ExactConversionsSupport.java | 11 ++- 2 files changed, 62 insertions(+), 18 deletions(-) diff --git a/make/jdk/src/classes/build/tools/taglet/JSpec.java b/make/jdk/src/classes/build/tools/taglet/JSpec.java index 1c301e94a8a..7e1e0ca215e 100644 --- a/make/jdk/src/classes/build/tools/taglet/JSpec.java +++ b/make/jdk/src/classes/build/tools/taglet/JSpec.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -49,13 +49,15 @@ import static com.sun.source.doctree.DocTree.Kind.*; * The tags can be used as follows: * * 

    - * @jls section-number description
+ * @jls chapter.section description
+ * @jls preview-feature-chapter.section description
  *
    * * For example: * * 
      * @jls 3.4 Line Terminators
+ * @jls primitive-types-in-patterns-instanceof-switch-5.7.1 Exact Testing Conversions
  *
    * * will produce the following HTML, depending on the file containing @@ -64,10 +66,24 @@ import static com.sun.source.doctree.DocTree.Kind.*; * 
    {@code
  * 
    See Java Language Specification:
  * 
    3.4 Line terminators
+ * 
    
+ * 5.7.1 Exact Testing Conversions
+ * PREVIEW
  * }
    * - * Copies of JLS and JVMS are expected to have been placed in the {@code specs} - * folder. These documents are not included in open-source repositories. + * In inline tags (note you need manual JLS/JVMS prefix): + * 
    + * JLS {@jls 3.4}
+ *
    + * + * produces (note the section sign and no trailing dot): + * 
    + * JLS §3.4
+ *
    + * + * Copies of JLS, JVMS, and preview JLS and JVMS changes are expected to have + * been placed in the {@code specs} folder. These documents are not included + * in open-source repositories. */ public class JSpec implements Taglet { @@ -87,9 +103,9 @@ public class JSpec implements Taglet { } } - private String tagName; - private String specTitle; - private String idPrefix; + private final String tagName; + private final String specTitle; + private final String idPrefix; JSpec(String tagName, String specTitle, String idPrefix) { this.tagName = tagName; @@ -98,7 +114,7 @@ public class JSpec implements Taglet { } // Note: Matches special cases like @jvms 6.5.checkcast - private static final Pattern TAG_PATTERN = Pattern.compile("(?s)(.+ )?(?[1-9][0-9]*)(?
    [0-9a-z_.]*)( .*)?$"); + private static final Pattern TAG_PATTERN = Pattern.compile("(?s)(.+ )?(?([a-z0-9]+-)+)?(?[1-9][0-9]*)(?
    [0-9a-z_.]*)( .*)?$"); /** * Returns the set of locations in which the tag may be used. @@ -157,19 +173,50 @@ public class JSpec implements Taglet { .trim(); Matcher m = TAG_PATTERN.matcher(tagText); if (m.find()) { + // preview-feature-4.6 is preview-feature-, 4, .6 + String preview = m.group("preview"); // null if no preview feature String chapter = m.group("chapter"); String section = m.group("section"); String rootParent = currentPath().replaceAll("[^/]+", ".."); - String url = String.format("%1$s/specs/%2$s/%2$s-%3$s.html#%2$s-%3$s%4$s", - rootParent, idPrefix, chapter, section); + String url = preview == null ? + String.format("%1$s/specs/%2$s/%2$s-%3$s.html#%2$s-%3$s%4$s", + rootParent, idPrefix, chapter, section) : + String.format("%1$s/specs/%5$s%2$s.html#%2$s-%3$s%4$s", + rootParent, idPrefix, chapter, section, preview); + + var literal = expand(contents).trim(); + var prefix = (preview == null ? "" : preview) + chapter + section; + if (literal.startsWith(prefix)) { + var hasFullTitle = literal.length() > prefix.length(); + if (hasFullTitle) { + // Drop the preview identifier + literal = chapter + section + literal.substring(prefix.length()); + } else { + // No section sign if the tag refers to a chapter, like {@jvms 4} + String sectionSign = section.isEmpty() ? "" : "§"; + // Change whole text to "§chapter.x" in inline tags. + literal = sectionSign + chapter + section; + } + } sb.append("") - .append(expand(contents)) + .append(literal) .append(""); + if (preview != null) { + // Add PREVIEW superscript that links to JLS/JVMS 1.5.1 + // "Restrictions on the Use of Preview Features" + // Similar to how APIs link to the Preview info box warning + var sectionLink = String.format("%1$s/specs/%2$s/%2$s-%3$s.html#%2$s-%3$s%4$s", + rootParent, idPrefix, "1", ".5.1"); + sb.append("PREVIEW"); + } + if (tag.getKind() == DocTree.Kind.UNKNOWN_BLOCK_TAG) { sb.append("
    "); } diff --git a/src/java.base/share/classes/java/lang/runtime/ExactConversionsSupport.java b/src/java.base/share/classes/java/lang/runtime/ExactConversionsSupport.java index a1a93859c42..8d4389f7295 100644 --- a/src/java.base/share/classes/java/lang/runtime/ExactConversionsSupport.java +++ b/src/java.base/share/classes/java/lang/runtime/ExactConversionsSupport.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, 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 @@ -64,12 +64,9 @@ package java.lang.runtime; * floating-point type is considered exact. * * - * @see - * JLS 5.7.1 Exact Testing Conversions - * @see - * JLS 5.7.2 Unconditionally Exact Testing Conversions - * @see - * JLS 15.20.2 The instanceof Operator + * @jls primitive-types-in-patterns-instanceof-switch-5.7.1 Exact Testing Conversions + * @jls primitive-types-in-patterns-instanceof-switch-5.7.2 Unconditionally Exact Testing Conversions + * @jls primitive-types-in-patterns-instanceof-switch-15.20.2 The {@code instanceof} Operator * * @implNote Some exactness checks describe a test which can be redirected * safely through one of the existing methods. Those are omitted too (i.e., From e8048c87bc9c152932ee59cb674bdb6670db2a56 Mon Sep 17 00:00:00 2001 From: Roger Riggs Date: Tue, 27 Jan 2026 16:07:45 +0000 Subject: [PATCH 081/105] 8376509: [process] Problemlist Test java/lang/ProcessBuilder/PipelineLeaksFD.java Reviewed-by: jpai --- test/jdk/ProblemList.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/test/jdk/ProblemList.txt b/test/jdk/ProblemList.txt index 291b2163b0d..5e8406b13a6 100644 --- a/test/jdk/ProblemList.txt +++ b/test/jdk/ProblemList.txt @@ -503,6 +503,7 @@ java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java 8151492 generic- java/lang/invoke/LFCaching/LFGarbageCollectedTest.java 8078602 generic-all java/lang/invoke/lambda/LambdaFileEncodingSerialization.java 8249079 linux-all java/lang/invoke/RicochetTest.java 8251969 generic-all +java/lang/ProcessBuilder/PipelineLeaksFD.java 8375585 generic-all ############################################################################ From eb6e74b1fa794bf16f572d5dbce157d1cae4c505 Mon Sep 17 00:00:00 2001 From: Nizar Benalla Date: Tue, 27 Jan 2026 17:14:40 +0000 Subject: [PATCH 082/105] 8374176: Update --release 26 symbol information for JDK 26 build 32 Reviewed-by: liach, iris, darcy --- src/jdk.compiler/share/data/symbols/java.base-Q.sym.txt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/jdk.compiler/share/data/symbols/java.base-Q.sym.txt b/src/jdk.compiler/share/data/symbols/java.base-Q.sym.txt index 29ecd9f0304..9166b505c51 100644 --- a/src/jdk.compiler/share/data/symbols/java.base-Q.sym.txt +++ b/src/jdk.compiler/share/data/symbols/java.base-Q.sym.txt @@ -1,5 +1,5 @@ # -# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2025, 2026, 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 @@ -429,6 +429,10 @@ innerclass innerClass java/io/ObjectOutputStream$PutField outerClass java/io/Obj innerclass innerClass java/util/AbstractMap$SimpleImmutableEntry outerClass java/util/AbstractMap innerClassName SimpleImmutableEntry flags 9 innerclass innerClass java/util/concurrent/ConcurrentHashMap$CollectionView outerClass java/util/concurrent/ConcurrentHashMap innerClassName CollectionView flags 408 +class name java/util/concurrent/CopyOnWriteArraySet +header extends java/util/AbstractSet implements java/io/Serializable flags 21 signature Ljava/util/AbstractSet;Ljava/io/Serializable; +innerclass innerClass java/io/ObjectInputStream$GetField outerClass java/io/ObjectInputStream innerClassName GetField flags 409 + class name java/util/concurrent/StructuredTaskScope -method name open descriptor (Ljava/util/concurrent/StructuredTaskScope$Joiner;Ljava/util/function/Function;)Ljava/util/concurrent/StructuredTaskScope; method name open descriptor (Ljava/util/concurrent/StructuredTaskScope$Joiner;Ljava/util/function/UnaryOperator;)Ljava/util/concurrent/StructuredTaskScope; flags 9 signature (Ljava/util/concurrent/StructuredTaskScope$Joiner<-TT;+TR;>;Ljava/util/function/UnaryOperator;)Ljava/util/concurrent/StructuredTaskScope; From fa1b1d677ac492dfdd3110b9303a4c2b009046c8 Mon Sep 17 00:00:00 2001 From: Chris Plummer Date: Tue, 27 Jan 2026 20:39:35 +0000 Subject: [PATCH 083/105] 8375477: CoreUtils support for SA tests should attempt to locate and unzip core files when they have been zipped Reviewed-by: lmesnik, kevinw --- test/lib/jdk/test/lib/util/CoreUtils.java | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/test/lib/jdk/test/lib/util/CoreUtils.java b/test/lib/jdk/test/lib/util/CoreUtils.java index f7a486def2b..72c1d89af44 100644 --- a/test/lib/jdk/test/lib/util/CoreUtils.java +++ b/test/lib/jdk/test/lib/util/CoreUtils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, 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 @@ -203,6 +203,7 @@ public class CoreUtils { private static final String CORE_PATTERN_FILE_NAME = "/proc/sys/kernel/core_pattern"; private static final String LOCATION_STRING = "location: "; + private static final String ALT_LOCATION_STRING = "alternatively, falling back to"; private static String parseCoreFileLocationFromOutput(String crashOutputString) { System.out.println("crashOutputString = [" + crashOutputString + "]"); @@ -220,12 +221,25 @@ public class CoreUtils { // Find the core file name in the output. String coreWithPid; - if (stringWithLocation.contains("or ") && !Platform.isWindows()) { - Matcher m = Pattern.compile("or.* ([^ ]+[^\\)])\\)?").matcher(stringWithLocation); + if (Platform.isLinux() && stringWithLocation.contains(ALT_LOCATION_STRING)) { + /* + * If hotspot detects that /proc/sys/kernel/core_pattern starts with a "|", + * it generates a messages something like the following: + * # Core dump will be written. Default location: Determined by the following: + * "/var/bin/core.sh %p" (alternatively, falling back to + * /ws/jdk/build/linux-x64/test-support/jtreg_open_test_hotspot_jtreg_serviceability_sa_ClhsdbFindPC_java/scratch/2/core.10353) + * We try to detect this and glean this alternative path from the message. The + * hope here is that either this is where the core file actually ends up, or that + * the script referenced by the core_pattern is just zipping the core file, in + * which case a call to unzipCores() will have already unzipped the core file + * into this path. + */ + Matcher m = Pattern.compile(ALT_LOCATION_STRING + ".* ([^ ]+[^\\)])\\)?").matcher(stringWithLocation); if (!m.find()) { throw new RuntimeException("Couldn't find path to core inside location string"); } coreWithPid = m.group(1); + System.out.println("getCoreFileLocation found alt coreWithPid = " + coreWithPid); } else { coreWithPid = stringWithLocation.trim(); } From 1161a640abe454b47de95ed73452a78535160deb Mon Sep 17 00:00:00 2001 From: Prasanta Sadhukhan Date: Wed, 28 Jan 2026 06:58:50 +0000 Subject: [PATCH 084/105] 8373239: Test java/awt/print/PrinterJob/PageRanges.java fails with incorrect selection of printed pages Reviewed-by: prr, aivanov --- .../windows/classes/sun/awt/windows/WPrinterJob.java | 6 +++++- test/jdk/java/awt/print/PrinterJob/PageRanges.java | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/java.desktop/windows/classes/sun/awt/windows/WPrinterJob.java b/src/java.desktop/windows/classes/sun/awt/windows/WPrinterJob.java index 01be8587685..1da9db3a35b 100644 --- a/src/java.desktop/windows/classes/sun/awt/windows/WPrinterJob.java +++ b/src/java.desktop/windows/classes/sun/awt/windows/WPrinterJob.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -1733,6 +1733,10 @@ public final class WPrinterJob extends RasterPrinterJob if (isRangeSet) { attributes.add(new PageRanges(from, to)); setPageRange(from, to); + } else { + attributes.remove(PageRanges.class); + setPageRange(Pageable.UNKNOWN_NUMBER_OF_PAGES, + Pageable.UNKNOWN_NUMBER_OF_PAGES); } defaultCopies = false; attributes.add(new Copies(copies)); diff --git a/test/jdk/java/awt/print/PrinterJob/PageRanges.java b/test/jdk/java/awt/print/PrinterJob/PageRanges.java index aea60516f78..691357d5a3c 100644 --- a/test/jdk/java/awt/print/PrinterJob/PageRanges.java +++ b/test/jdk/java/awt/print/PrinterJob/PageRanges.java @@ -23,7 +23,7 @@ /* * @test - * @bug 6575331 8297191 + * @bug 6575331 8297191 8373239 * @key printer * @summary The specified pages should be printed. * @library /java/awt/regtesthelpers From 88c8a55a4337a857ac17ffff068f730f67cf5763 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 28 Jan 2026 07:44:31 +0000 Subject: [PATCH 085/105] 8373266: Strengthen constant CardTable base accesses Reviewed-by: tschatzl, xpeng --- .../cpu/aarch64/macroAssembler_aarch64.cpp | 7 +++--- .../cardTableBarrierSetAssembler_arm.cpp | 15 +++++------- .../cardTableBarrierSetAssembler_ppc.cpp | 9 ++++---- .../shenandoahBarrierSetAssembler_ppc.cpp | 3 --- .../cpu/riscv/macroAssembler_riscv.cpp | 5 ++-- .../cardTableBarrierSetAssembler_s390.cpp | 10 ++++---- .../cardTableBarrierSetAssembler_x86.cpp | 15 ++++-------- .../os_cpu/linux_arm/javaThread_linux_arm.cpp | 3 ++- src/hotspot/share/ci/ciUtilities.cpp | 9 +++----- src/hotspot/share/ci/ciUtilities.hpp | 4 ++-- src/hotspot/share/compiler/disassembler.cpp | 23 ++++++++++++++++--- .../gc/shared/c1/cardTableBarrierSetC1.cpp | 7 ++---- .../gc/shared/c2/cardTableBarrierSetC2.cpp | 2 +- .../share/gc/shared/cardTableBarrierSet.hpp | 9 ++++++++ .../share/jvmci/jvmciCompilerToVMInit.cpp | 19 ++++++++++----- 15 files changed, 75 insertions(+), 65 deletions(-) diff --git a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp index 27428a5c558..e813a70372b 100644 --- a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp @@ -5606,12 +5606,11 @@ void MacroAssembler::adrp(Register reg1, const Address &dest, uint64_t &byte_off } void MacroAssembler::load_byte_map_base(Register reg) { - CardTable::CardValue* byte_map_base = - ((CardTableBarrierSet*)(BarrierSet::barrier_set()))->card_table()->byte_map_base(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); - // Strictly speaking the byte_map_base isn't an address at all, and it might + // Strictly speaking the card table base isn't an address at all, and it might // even be negative. It is thus materialised as a constant. - mov(reg, (uint64_t)byte_map_base); + mov(reg, (uint64_t)ctbs->card_table_base_const()); } void MacroAssembler::build_frame(int framesize) { diff --git a/src/hotspot/cpu/arm/gc/shared/cardTableBarrierSetAssembler_arm.cpp b/src/hotspot/cpu/arm/gc/shared/cardTableBarrierSetAssembler_arm.cpp index 2427d46cafa..5d63035ac69 100644 --- a/src/hotspot/cpu/arm/gc/shared/cardTableBarrierSetAssembler_arm.cpp +++ b/src/hotspot/cpu/arm/gc/shared/cardTableBarrierSetAssembler_arm.cpp @@ -67,9 +67,7 @@ void CardTableBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet d void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, Register addr, Register count, Register tmp) { BLOCK_COMMENT("CardTablePostBarrier"); - BarrierSet* bs = BarrierSet::barrier_set(); - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); Label L_cardtable_loop, L_done; @@ -83,7 +81,7 @@ void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembl __ sub(count, count, addr); // nb of cards // warning: Rthread has not been preserved - __ mov_address(tmp, (address) ct->byte_map_base()); + __ mov_address(tmp, (address)ctbs->card_table_base_const()); __ add(addr,tmp, addr); Register zero = __ zero_register(tmp); @@ -122,8 +120,7 @@ void CardTableBarrierSetAssembler::store_check_part1(MacroAssembler* masm, Regis assert(bs->kind() == BarrierSet::CardTableBarrierSet, "Wrong barrier set kind"); - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); // Load card table base address. @@ -140,7 +137,7 @@ void CardTableBarrierSetAssembler::store_check_part1(MacroAssembler* masm, Regis Possible cause is a cache miss (card table base address resides in a rarely accessed area of thread descriptor). */ - __ mov_address(card_table_base, (address)ct->byte_map_base()); + __ mov_address(card_table_base, (address)ctbs->card_table_base_const()); } // The 2nd part of the store check. @@ -170,8 +167,8 @@ void CardTableBarrierSetAssembler::store_check_part2(MacroAssembler* masm, Regis void CardTableBarrierSetAssembler::set_card(MacroAssembler* masm, Register card_table_base, Address card_table_addr, Register tmp) { CardTableBarrierSet* ctbs = barrier_set_cast(BarrierSet::barrier_set()); - CardTable* ct = ctbs->card_table(); - if ((((uintptr_t)ct->byte_map_base() & 0xff) == 0)) { + + if ((((uintptr_t)ctbs->card_table_base_const() & 0xff) == 0)) { // Card table is aligned so the lowest byte of the table address base is zero. // This works only if the code is not saved for later use, possibly // in a context where the base would no longer be aligned. diff --git a/src/hotspot/cpu/ppc/gc/shared/cardTableBarrierSetAssembler_ppc.cpp b/src/hotspot/cpu/ppc/gc/shared/cardTableBarrierSetAssembler_ppc.cpp index 7404f7e2e5c..297ce57a394 100644 --- a/src/hotspot/cpu/ppc/gc/shared/cardTableBarrierSetAssembler_ppc.cpp +++ b/src/hotspot/cpu/ppc/gc/shared/cardTableBarrierSetAssembler_ppc.cpp @@ -103,8 +103,7 @@ void CardTableBarrierSetAssembler::resolve_jobject(MacroAssembler* masm, Registe void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, Register addr, Register count, Register preserve) { - CardTableBarrierSet* ctbs = barrier_set_cast(BarrierSet::barrier_set()); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); assert_different_registers(addr, count, R0); Label Lskip_loop, Lstore_loop; @@ -117,7 +116,7 @@ void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembl __ srdi(addr, addr, CardTable::card_shift()); __ srdi(count, count, CardTable::card_shift()); __ subf(count, addr, count); - __ add_const_optimized(addr, addr, (address)ct->byte_map_base(), R0); + __ add_const_optimized(addr, addr, (address)ctbs->card_table_base_const(), R0); __ addi(count, count, 1); __ li(R0, 0); __ mtctr(count); @@ -140,8 +139,8 @@ void CardTableBarrierSetAssembler::card_table_write(MacroAssembler* masm, } void CardTableBarrierSetAssembler::card_write_barrier_post(MacroAssembler* masm, Register store_addr, Register tmp) { - CardTableBarrierSet* bs = barrier_set_cast(BarrierSet::barrier_set()); - card_table_write(masm, bs->card_table()->byte_map_base(), tmp, store_addr); + CardTableBarrierSet* bs = CardTableBarrierSet::barrier_set(); + card_table_write(masm, bs->card_table_base_const(), tmp, store_addr); } void CardTableBarrierSetAssembler::oop_store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, diff --git a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp index 1f1bc7622ed..9d143c14d27 100644 --- a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp +++ b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp @@ -771,9 +771,6 @@ void ShenandoahBarrierSetAssembler::cmpxchg_oop(MacroAssembler *masm, Register b void ShenandoahBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, Register addr, Register count, Register preserve) { assert(ShenandoahCardBarrier, "Should have been checked by caller"); - - ShenandoahBarrierSet* bs = ShenandoahBarrierSet::barrier_set(); - CardTable* ct = bs->card_table(); assert_different_registers(addr, count, R0); Label L_skip_loop, L_store_loop; diff --git a/src/hotspot/cpu/riscv/macroAssembler_riscv.cpp b/src/hotspot/cpu/riscv/macroAssembler_riscv.cpp index 43b17a13c20..fb30f64e9ed 100644 --- a/src/hotspot/cpu/riscv/macroAssembler_riscv.cpp +++ b/src/hotspot/cpu/riscv/macroAssembler_riscv.cpp @@ -5110,9 +5110,8 @@ void MacroAssembler::get_thread(Register thread) { } void MacroAssembler::load_byte_map_base(Register reg) { - CardTable::CardValue* byte_map_base = - ((CardTableBarrierSet*)(BarrierSet::barrier_set()))->card_table()->byte_map_base(); - mv(reg, (uint64_t)byte_map_base); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); + mv(reg, (uint64_t)ctbs->card_table_base_const()); } void MacroAssembler::build_frame(int framesize) { diff --git a/src/hotspot/cpu/s390/gc/shared/cardTableBarrierSetAssembler_s390.cpp b/src/hotspot/cpu/s390/gc/shared/cardTableBarrierSetAssembler_s390.cpp index a0da6ebe682..9bb7f63ff31 100644 --- a/src/hotspot/cpu/s390/gc/shared/cardTableBarrierSetAssembler_s390.cpp +++ b/src/hotspot/cpu/s390/gc/shared/cardTableBarrierSetAssembler_s390.cpp @@ -83,8 +83,7 @@ void CardTableBarrierSetAssembler::resolve_jobject(MacroAssembler* masm, Registe void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, Register addr, Register count, bool do_return) { - CardTableBarrierSet* ctbs = barrier_set_cast(BarrierSet::barrier_set()); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); NearLabel doXC, done; assert_different_registers(Z_R0, Z_R1, addr, count); @@ -105,7 +104,7 @@ void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembl __ add2reg_with_index(count, -BytesPerHeapOop, count, addr); // Get base address of card table. - __ load_const_optimized(Z_R1, (address)ct->byte_map_base()); + __ load_const_optimized(Z_R1, (address)ctbs->card_table_base_const()); // count = (count>>shift) - (addr>>shift) __ z_srlg(addr, addr, CardTable::card_shift()); @@ -179,13 +178,12 @@ void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembl void CardTableBarrierSetAssembler::store_check(MacroAssembler* masm, Register store_addr, Register tmp) { // Does a store check for the oop in register obj. The content of // register obj is destroyed afterwards. - CardTableBarrierSet* ctbs = barrier_set_cast(BarrierSet::barrier_set()); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); assert_different_registers(store_addr, tmp); __ z_srlg(store_addr, store_addr, CardTable::card_shift()); - __ load_absolute_address(tmp, (address)ct->byte_map_base()); + __ load_absolute_address(tmp, (address)ctbs->card_table_base_const()); __ z_agr(store_addr, tmp); __ z_mvi(0, store_addr, CardTable::dirty_card_val()); } diff --git a/src/hotspot/cpu/x86/gc/shared/cardTableBarrierSetAssembler_x86.cpp b/src/hotspot/cpu/x86/gc/shared/cardTableBarrierSetAssembler_x86.cpp index 2b91662ddb5..65e6b4e01fc 100644 --- a/src/hotspot/cpu/x86/gc/shared/cardTableBarrierSetAssembler_x86.cpp +++ b/src/hotspot/cpu/x86/gc/shared/cardTableBarrierSetAssembler_x86.cpp @@ -95,11 +95,7 @@ void CardTableBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet d void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, Register addr, Register count, Register tmp) { - BarrierSet *bs = BarrierSet::barrier_set(); - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); - intptr_t disp = (intptr_t) ct->byte_map_base(); - SHENANDOAHGC_ONLY(assert(!UseShenandoahGC, "Shenandoah byte_map_base is not constant.");) + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); Label L_loop, L_done; const Register end = count; @@ -115,7 +111,7 @@ void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembl __ shrptr(end, CardTable::card_shift()); __ subptr(end, addr); // end --> cards count - __ mov64(tmp, disp); + __ mov64(tmp, (intptr_t)ctbs->card_table_base_const()); __ addptr(addr, tmp); __ BIND(L_loop); __ movb(Address(addr, count, Address::times_1), 0); @@ -128,10 +124,7 @@ __ BIND(L_done); void CardTableBarrierSetAssembler::store_check(MacroAssembler* masm, Register obj, Address dst) { // Does a store check for the oop in register obj. The content of // register obj is destroyed afterwards. - BarrierSet* bs = BarrierSet::barrier_set(); - - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); __ shrptr(obj, CardTable::card_shift()); @@ -142,7 +135,7 @@ void CardTableBarrierSetAssembler::store_check(MacroAssembler* masm, Register ob // So this essentially converts an address to a displacement and it will // never need to be relocated. On 64bit however the value may be too // large for a 32bit displacement. - intptr_t byte_map_base = (intptr_t)ct->byte_map_base(); + intptr_t byte_map_base = (intptr_t)ctbs->card_table_base_const(); if (__ is_simm32(byte_map_base)) { card_addr = Address(noreg, obj, Address::times_1, byte_map_base); } else { diff --git a/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp b/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp index 3dc0035ed87..d82b9d90417 100644 --- a/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp +++ b/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp @@ -43,7 +43,8 @@ void JavaThread::cache_global_variables() { BarrierSet* bs = BarrierSet::barrier_set(); if (bs->is_a(BarrierSet::CardTableBarrierSet)) { - _card_table_base = (address) (barrier_set_cast(bs)->card_table()->byte_map_base()); + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); + _card_table_base = (address)ctbs->card_table_base_const(); } else { _card_table_base = nullptr; } diff --git a/src/hotspot/share/ci/ciUtilities.cpp b/src/hotspot/share/ci/ciUtilities.cpp index 0c5b4d9824f..011fa049275 100644 --- a/src/hotspot/share/ci/ciUtilities.cpp +++ b/src/hotspot/share/ci/ciUtilities.cpp @@ -42,10 +42,7 @@ const char* basictype_to_str(BasicType t) { // ------------------------------------------------------------------ // card_table_base -CardTable::CardValue* ci_card_table_address() { - BarrierSet* bs = BarrierSet::barrier_set(); - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); - assert(!UseShenandoahGC, "Shenandoah byte_map_base is not constant."); - return ct->byte_map_base(); +CardTable::CardValue* ci_card_table_address_const() { + CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set(); + return ctbs->card_table_base_const(); } diff --git a/src/hotspot/share/ci/ciUtilities.hpp b/src/hotspot/share/ci/ciUtilities.hpp index 75dbb03adf4..3333972d57d 100644 --- a/src/hotspot/share/ci/ciUtilities.hpp +++ b/src/hotspot/share/ci/ciUtilities.hpp @@ -51,9 +51,9 @@ inline const char* bool_to_str(bool b) { const char* basictype_to_str(BasicType t); -CardTable::CardValue* ci_card_table_address(); +CardTable::CardValue* ci_card_table_address_const(); template T ci_card_table_address_as() { - return reinterpret_cast(ci_card_table_address()); + return reinterpret_cast(ci_card_table_address_const()); } #endif // SHARE_CI_CIUTILITIES_HPP diff --git a/src/hotspot/share/compiler/disassembler.cpp b/src/hotspot/share/compiler/disassembler.cpp index c79c15e0f32..2c1ef235e07 100644 --- a/src/hotspot/share/compiler/disassembler.cpp +++ b/src/hotspot/share/compiler/disassembler.cpp @@ -607,10 +607,27 @@ void decode_env::print_address(address adr) { return; } + address card_table_base = nullptr; BarrierSet* bs = BarrierSet::barrier_set(); - if (bs->is_a(BarrierSet::CardTableBarrierSet) && - adr == ci_card_table_address_as
    ()) { - st->print("word_map_base"); +#if INCLUDE_G1GC + if (bs->is_a(BarrierSet::G1BarrierSet)) { + G1BarrierSet* g1bs = barrier_set_cast(bs); + card_table_base = g1bs->card_table()->byte_map_base(); + } else +#endif +#if INCLUDE_SHENANDOAHGC + if (bs->is_a(BarrierSet::ShenandoahBarrierSet)) { + ShenandoahBarrierSet* sbs = barrier_set_cast(bs); + if (sbs->card_table() != nullptr) { + card_table_base = sbs->card_table()->byte_map_base(); + } + } else +#endif + if (bs->is_a(BarrierSet::CardTableBarrierSet)) { + card_table_base = ci_card_table_address_as
    (); + } + if (card_table_base != nullptr && adr == card_table_base) { + st->print("card_table_base"); if (WizardMode) st->print(" " INTPTR_FORMAT, p2i(adr)); return; } diff --git a/src/hotspot/share/gc/shared/c1/cardTableBarrierSetC1.cpp b/src/hotspot/share/gc/shared/c1/cardTableBarrierSetC1.cpp index ebc1c1c7fb7..914358760aa 100644 --- a/src/hotspot/share/gc/shared/c1/cardTableBarrierSetC1.cpp +++ b/src/hotspot/share/gc/shared/c1/cardTableBarrierSetC1.cpp @@ -104,11 +104,8 @@ void CardTableBarrierSetC1::post_barrier(LIRAccess& access, LIR_Opr addr, LIR_Op return; } - BarrierSet* bs = BarrierSet::barrier_set(); - CardTableBarrierSet* ctbs = barrier_set_cast(bs); - CardTable* ct = ctbs->card_table(); - LIR_Const* card_table_base = new LIR_Const(ct->byte_map_base()); - SHENANDOAHGC_ONLY(assert(!UseShenandoahGC, "Shenandoah byte_map_base is not constant.");) + CardTableBarrierSet* ctbs = barrier_set_cast(BarrierSet::barrier_set()); + LIR_Const* card_table_base = new LIR_Const(ctbs->card_table_base_const()); if (addr->is_address()) { LIR_Address* address = addr->as_address_ptr(); diff --git a/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp b/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp index fada2672e9f..42af77ebdf4 100644 --- a/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp +++ b/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp @@ -116,7 +116,7 @@ Node* CardTableBarrierSetC2::atomic_xchg_at_resolved(C2AtomicParseAccess& access Node* CardTableBarrierSetC2::byte_map_base_node(GraphKit* kit) const { // Get base of card map - CardTable::CardValue* card_table_base = ci_card_table_address(); + CardTable::CardValue* card_table_base = ci_card_table_address_const(); if (card_table_base != nullptr) { return kit->makecon(TypeRawPtr::make((address)card_table_base)); } else { diff --git a/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp b/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp index faeb007c77d..c298bfcd0c2 100644 --- a/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp +++ b/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp @@ -27,6 +27,7 @@ #include "gc/shared/barrierSet.hpp" #include "gc/shared/cardTable.hpp" +#include "gc/shared/gc_globals.hpp" #include "memory/memRegion.hpp" #include "utilities/align.hpp" @@ -60,6 +61,10 @@ public: CardTableBarrierSet(CardTable* card_table); virtual ~CardTableBarrierSet(); + inline static CardTableBarrierSet* barrier_set() { + return barrier_set_cast(BarrierSet::barrier_set()); + } + template inline void write_ref_field_pre(T* addr) {} @@ -86,6 +91,10 @@ public: inline void write_ref_array(HeapWord* start, size_t count); CardTable* card_table() const { return _card_table; } + CardValue* card_table_base_const() const { + assert(UseSerialGC || UseParallelGC, "Only these GCs have constant card table base"); + return _card_table->byte_map_base(); + } virtual void on_slowpath_allocation_exit(JavaThread* thread, oop new_obj); diff --git a/src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp b/src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp index 801a9bf8eb4..3e9d8c97b88 100644 --- a/src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp +++ b/src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp @@ -236,16 +236,23 @@ void CompilerToVM::Data::initialize(JVMCI_TRAPS) { JVMTI_ONLY( _should_notify_object_alloc = &JvmtiExport::_should_notify_object_alloc; ) BarrierSet* bs = BarrierSet::barrier_set(); +#if INCLUDE_G1GC + if (bs->is_a(BarrierSet::G1BarrierSet)) { + cardtable_start_address = nullptr; + cardtable_shift = CardTable::card_shift(); + } else +#endif +#if INCLUDE_SHENANDOAHGC + if (bs->is_a(BarrierSet::ShenandoahBarrierSet)) { + cardtable_start_address = nullptr; + cardtable_shift = CardTable::card_shift(); + } else +#endif if (bs->is_a(BarrierSet::CardTableBarrierSet)) { - CardTable::CardValue* base = ci_card_table_address(); + CardTable::CardValue* base = ci_card_table_address_const(); assert(base != nullptr, "unexpected byte_map_base"); cardtable_start_address = base; cardtable_shift = CardTable::card_shift(); -#if INCLUDE_SHENANDOAHGC - } else if (bs->is_a(BarrierSet::ShenandoahBarrierSet)) { - cardtable_start_address = nullptr; - cardtable_shift = CardTable::card_shift(); -#endif } else { // No card mark barriers cardtable_start_address = nullptr; From b2cd3b0d48bdabacfd421dee9b9f87a003e0e09d Mon Sep 17 00:00:00 2001 From: Roland Westrelin Date: Wed, 28 Jan 2026 08:00:11 +0000 Subject: [PATCH 086/105] 8350330: C2: PhaseIdealLoop::add_parse_predicate() should mirror GraphKit::add_parse_predicate() Reviewed-by: chagedorn, qamai --- src/hotspot/share/opto/loopnode.cpp | 44 +++++------ src/hotspot/share/opto/loopnode.hpp | 3 + .../TestLoopNestTooManyTraps.java | 79 +++++++++++++++++++ 3 files changed, 103 insertions(+), 23 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/longcountedloops/TestLoopNestTooManyTraps.java diff --git a/src/hotspot/share/opto/loopnode.cpp b/src/hotspot/share/opto/loopnode.cpp index 8dc34af9c19..fab354e3e3d 100644 --- a/src/hotspot/share/opto/loopnode.cpp +++ b/src/hotspot/share/opto/loopnode.cpp @@ -590,7 +590,7 @@ Node* PhaseIdealLoop::loop_nest_replace_iv(Node* iv_to_replace, Node* inner_iv, // Add a Parse Predicate with an uncommon trap on the failing/false path. Normal control will continue on the true path. void PhaseIdealLoop::add_parse_predicate(Deoptimization::DeoptReason reason, Node* inner_head, IdealLoopTree* loop, SafePointNode* sfpt) { - if (!C->too_many_traps(reason)) { + if (!C->too_many_traps(sfpt->jvms()->method(), sfpt->jvms()->bci(), reason)) { ParsePredicateNode* parse_predicate = new ParsePredicateNode(inner_head->in(LoopNode::EntryControl), reason, &_igvn); register_control(parse_predicate, loop, inner_head->in(LoopNode::EntryControl)); Node* if_false = new IfFalseNode(parse_predicate); @@ -760,6 +760,24 @@ SafePointNode* PhaseIdealLoop::find_safepoint(Node* back_control, Node* x, Ideal return safepoint; } +void PhaseIdealLoop::add_parse_predicates(IdealLoopTree* outer_ilt, LoopNode* inner_head, SafePointNode* cloned_sfpt) { + if (ShortRunningLongLoop) { + add_parse_predicate(Deoptimization::Reason_short_running_long_loop, inner_head, outer_ilt, cloned_sfpt); + } + if (UseLoopPredicate) { + add_parse_predicate(Deoptimization::Reason_predicate, inner_head, outer_ilt, cloned_sfpt); + if (UseProfiledLoopPredicate) { + add_parse_predicate(Deoptimization::Reason_profile_predicate, inner_head, outer_ilt, cloned_sfpt); + } + } + + if (UseAutoVectorizationPredicate) { + add_parse_predicate(Deoptimization::Reason_auto_vectorization_check, inner_head, outer_ilt, cloned_sfpt); + } + + add_parse_predicate(Deoptimization::Reason_loop_limit_check, inner_head, outer_ilt, cloned_sfpt); +} + // If the loop has the shape of a counted loop but with a long // induction variable, transform the loop in a loop nest: an inner // loop that iterates for at most max int iterations with an integer @@ -1123,26 +1141,7 @@ bool PhaseIdealLoop::create_loop_nest(IdealLoopTree* loop, Node_List &old_new) { if (safepoint != nullptr) { SafePointNode* cloned_sfpt = old_new[safepoint->_idx]->as_SafePoint(); - if (ShortRunningLongLoop) { - add_parse_predicate(Deoptimization::Reason_short_running_long_loop, inner_head, outer_ilt, cloned_sfpt); - } - if (UseLoopPredicate) { - add_parse_predicate(Deoptimization::Reason_predicate, inner_head, outer_ilt, cloned_sfpt); - if (UseProfiledLoopPredicate) { - add_parse_predicate(Deoptimization::Reason_profile_predicate, inner_head, outer_ilt, cloned_sfpt); - } - } - - if (UseAutoVectorizationPredicate) { - // We only want to use the auto-vectorization check as a trap once per bci. And - // PhaseIdealLoop::add_parse_predicate only checks trap limits per method, so - // we do a custom check here. - if (!C->too_many_traps(cloned_sfpt->jvms()->method(), cloned_sfpt->jvms()->bci(), Deoptimization::Reason_auto_vectorization_check)) { - add_parse_predicate(Deoptimization::Reason_auto_vectorization_check, inner_head, outer_ilt, cloned_sfpt); - } - } - - add_parse_predicate(Deoptimization::Reason_loop_limit_check, inner_head, outer_ilt, cloned_sfpt); + add_parse_predicates(outer_ilt, inner_head, cloned_sfpt); } #ifndef PRODUCT @@ -1893,7 +1892,7 @@ bool PhaseIdealLoop::convert_to_long_loop(Node* cmp, Node* phi, IdealLoopTree* l #endif //------------------------------is_counted_loop-------------------------------- -bool PhaseIdealLoop::is_counted_loop(Node* x, IdealLoopTree*&loop, BasicType iv_bt) { +bool PhaseIdealLoop::is_counted_loop(Node* x, IdealLoopTree*& loop, BasicType iv_bt) { PhaseGVN *gvn = &_igvn; Node* back_control = loop_exit_control(x, loop); @@ -3528,7 +3527,6 @@ void OuterStripMinedLoopNode::transform_to_counted_loop(PhaseIterGVN* igvn, Phas CountedLoopEndNode* cle = inner_cl->loopexit(); Node* inner_test = cle->in(1); IfNode* outer_le = outer_loop_end(); - CountedLoopEndNode* inner_cle = inner_cl->loopexit(); Node* safepoint = outer_safepoint(); fix_sunk_stores_when_back_to_counted_loop(igvn, iloop); diff --git a/src/hotspot/share/opto/loopnode.hpp b/src/hotspot/share/opto/loopnode.hpp index ffc283ac941..24976d76a51 100644 --- a/src/hotspot/share/opto/loopnode.hpp +++ b/src/hotspot/share/opto/loopnode.hpp @@ -1368,6 +1368,9 @@ public: #endif void add_parse_predicate(Deoptimization::DeoptReason reason, Node* inner_head, IdealLoopTree* loop, SafePointNode* sfpt); SafePointNode* find_safepoint(Node* back_control, Node* x, IdealLoopTree* loop); + + void add_parse_predicates(IdealLoopTree* outer_ilt, LoopNode* inner_head, SafePointNode* cloned_sfpt); + IdealLoopTree* insert_outer_loop(IdealLoopTree* loop, LoopNode* outer_l, Node* outer_ift); IdealLoopTree* create_outer_strip_mined_loop(Node* init_control, IdealLoopTree* loop, float cl_prob, float le_fcnt, diff --git a/test/hotspot/jtreg/compiler/longcountedloops/TestLoopNestTooManyTraps.java b/test/hotspot/jtreg/compiler/longcountedloops/TestLoopNestTooManyTraps.java new file mode 100644 index 00000000000..502afc56548 --- /dev/null +++ b/test/hotspot/jtreg/compiler/longcountedloops/TestLoopNestTooManyTraps.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2026 IBM Corporation. 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 8350330 + * @summary C2: PhaseIdealLoop::add_parse_predicate() should mirror GraphKit::add_parse_predicate() + * @library /test/lib / + * @build jdk.test.whitebox.WhiteBox + * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox + * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI + * -XX:-BackgroundCompilation -XX:-ShortRunningLongLoop -XX:-UseOnStackReplacement + * -XX:CompileOnly=*TestLoopNestTooManyTraps::test1 -XX:LoopMaxUnroll=0 + * compiler.longcountedloops.TestLoopNestTooManyTraps + */ + +package compiler.longcountedloops; + +import java.lang.reflect.Method; +import java.util.Objects; +import jdk.test.whitebox.WhiteBox; + +public class TestLoopNestTooManyTraps { + private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); + + public static void main(String[] args) throws NoSuchMethodException { + Method methodTest1 = TestLoopNestTooManyTraps.class.getDeclaredMethod("test1", int.class, long.class); + + for (int j = 0; j < 10; j++) { + System.out.println("iteration " + j); + for (int i = 0; i < 20_000; i++) { + test1(1000, 1000); + } + if (!WHITE_BOX.isMethodCompiled(methodTest1)) { + throw new RuntimeException("test1 should be compiled"); + } + System.out.println("iteration 2 " + j); + try { + test1(10000, 1000); + } catch (IndexOutOfBoundsException ioobe) { + } + if (j <= 1) { + if (WHITE_BOX.isMethodCompiled(methodTest1)) { + throw new RuntimeException("test1 should have deoptimized at iteration " + j); + } + } else { + if (!WHITE_BOX.isMethodCompiled(methodTest1)) { + throw new RuntimeException("test1 shouldn't have deoptimized"); + } + } + } + } + + private static void test1(int stop, long length) { + for (int i = 0; i < stop; i++) { + Objects.checkIndex(i, length); + } + } +} From 4ae4ffd5a3114aa2a3832818ee30dc38d9aa2b72 Mon Sep 17 00:00:00 2001 From: Chad Rakoczy Date: Wed, 28 Jan 2026 08:08:36 +0000 Subject: [PATCH 087/105] 8374513: AArch64: Improve receiver type profiling reliability Reviewed-by: shade, aph --- .../cpu/aarch64/c1_LIRAssembler_aarch64.cpp | 92 ++--------- .../cpu/aarch64/c1_LIRAssembler_aarch64.hpp | 5 +- .../cpu/aarch64/interp_masm_aarch64.cpp | 137 +--------------- .../cpu/aarch64/interp_masm_aarch64.hpp | 12 +- .../cpu/aarch64/macroAssembler_aarch64.cpp | 155 ++++++++++++++++++ .../cpu/aarch64/macroAssembler_aarch64.hpp | 2 + .../cpu/aarch64/templateTable_aarch64.cpp | 4 +- 7 files changed, 179 insertions(+), 228 deletions(-) diff --git a/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp index 37a6a130e0d..c0621cbd5c2 100644 --- a/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp @@ -1218,43 +1218,11 @@ void LIR_Assembler::emit_alloc_array(LIR_OpAllocArray* op) { __ bind(*op->stub()->continuation()); } -void LIR_Assembler::type_profile_helper(Register mdo, - ciMethodData *md, ciProfileData *data, - Register recv, Label* update_done) { +void LIR_Assembler::type_profile_helper(Register mdo, ciMethodData *md, + ciProfileData *data, Register recv) { - // Given a profile data offset, generate an Address which points to - // the corresponding slot in mdo->data(). - // Clobbers rscratch2. - auto slot_at = [=](ByteSize offset) -> Address { - return __ form_address(rscratch2, mdo, - md->byte_offset_of_slot(data, offset), - LogBytesPerWord); - }; - - for (uint i = 0; i < ReceiverTypeData::row_limit(); i++) { - Label next_test; - // See if the receiver is receiver[n]. - __ ldr(rscratch1, slot_at(ReceiverTypeData::receiver_offset(i))); - __ cmp(recv, rscratch1); - __ br(Assembler::NE, next_test); - __ addptr(slot_at(ReceiverTypeData::receiver_count_offset(i)), - DataLayout::counter_increment); - __ b(*update_done); - __ bind(next_test); - } - - // Didn't find receiver; find next empty slot and fill it in - for (uint i = 0; i < ReceiverTypeData::row_limit(); i++) { - Label next_test; - Address recv_addr(slot_at(ReceiverTypeData::receiver_offset(i))); - __ ldr(rscratch1, recv_addr); - __ cbnz(rscratch1, next_test); - __ str(recv, recv_addr); - __ mov(rscratch1, DataLayout::counter_increment); - __ str(rscratch1, slot_at(ReceiverTypeData::receiver_count_offset(i))); - __ b(*update_done); - __ bind(next_test); - } + int mdp_offset = md->byte_offset_of_slot(data, in_ByteSize(0)); + __ profile_receiver_type(recv, mdo, mdp_offset); } void LIR_Assembler::emit_typecheck_helper(LIR_OpTypeCheck *op, Label* success, Label* failure, Label* obj_is_null) { @@ -1316,14 +1284,9 @@ void LIR_Assembler::emit_typecheck_helper(LIR_OpTypeCheck *op, Label* success, L __ b(*obj_is_null); __ bind(not_null); - Label update_done; Register recv = k_RInfo; __ load_klass(recv, obj); - type_profile_helper(mdo, md, data, recv, &update_done); - Address counter_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset())); - __ addptr(counter_addr, DataLayout::counter_increment); - - __ bind(update_done); + type_profile_helper(mdo, md, data, recv); } else { __ cbz(obj, *obj_is_null); } @@ -1430,13 +1393,9 @@ void LIR_Assembler::emit_opTypeCheck(LIR_OpTypeCheck* op) { __ b(done); __ bind(not_null); - Label update_done; Register recv = k_RInfo; __ load_klass(recv, value); - type_profile_helper(mdo, md, data, recv, &update_done); - Address counter_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset())); - __ addptr(counter_addr, DataLayout::counter_increment); - __ bind(update_done); + type_profile_helper(mdo, md, data, recv); } else { __ cbz(value, done); } @@ -2540,13 +2499,9 @@ void LIR_Assembler::emit_profile_call(LIR_OpProfileCall* op) { if (C1OptimizeVirtualCallProfiling && known_klass != nullptr) { // We know the type that will be seen at this call site; we can // statically update the MethodData* rather than needing to do - // dynamic tests on the receiver type - - // NOTE: we should probably put a lock around this search to - // avoid collisions by concurrent compilations + // dynamic tests on the receiver type. ciVirtualCallData* vc_data = (ciVirtualCallData*) data; - uint i; - for (i = 0; i < VirtualCallData::row_limit(); i++) { + for (uint i = 0; i < VirtualCallData::row_limit(); i++) { ciKlass* receiver = vc_data->receiver(i); if (known_klass->equals(receiver)) { Address data_addr(mdo, md->byte_offset_of_slot(data, VirtualCallData::receiver_count_offset(i))); @@ -2554,36 +2509,13 @@ void LIR_Assembler::emit_profile_call(LIR_OpProfileCall* op) { return; } } - - // Receiver type not found in profile data; select an empty slot - - // Note that this is less efficient than it should be because it - // always does a write to the receiver part of the - // VirtualCallData rather than just the first time - for (i = 0; i < VirtualCallData::row_limit(); i++) { - ciKlass* receiver = vc_data->receiver(i); - if (receiver == nullptr) { - __ mov_metadata(rscratch1, known_klass->constant_encoding()); - Address recv_addr = - __ form_address(rscratch2, mdo, - md->byte_offset_of_slot(data, VirtualCallData::receiver_offset(i)), - LogBytesPerWord); - __ str(rscratch1, recv_addr); - Address data_addr(mdo, md->byte_offset_of_slot(data, VirtualCallData::receiver_count_offset(i))); - __ addptr(data_addr, DataLayout::counter_increment); - return; - } - } + // Receiver type is not found in profile data. + // Fall back to runtime helper to handle the rest at runtime. + __ mov_metadata(recv, known_klass->constant_encoding()); } else { __ load_klass(recv, recv); - Label update_done; - type_profile_helper(mdo, md, data, recv, &update_done); - // Receiver did not match any saved receiver and there is no empty row for it. - // Increment total counter to indicate polymorphic case. - __ addptr(counter_addr, DataLayout::counter_increment); - - __ bind(update_done); } + type_profile_helper(mdo, md, data, recv); } else { // Static call __ addptr(counter_addr, DataLayout::counter_increment); diff --git a/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.hpp b/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.hpp index 21916a5f7dd..5af06fc6a1c 100644 --- a/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.hpp +++ b/src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.hpp @@ -50,9 +50,8 @@ friend class ArrayCopyStub; Address stack_slot_address(int index, uint shift, Register tmp, int adjust = 0); // Record the type of the receiver in ReceiverTypeData - void type_profile_helper(Register mdo, - ciMethodData *md, ciProfileData *data, - Register recv, Label* update_done); + void type_profile_helper(Register mdo, ciMethodData *md, + ciProfileData *data, Register recv); void add_debug_info_for_branch(address adr, CodeEmitInfo* info); void casw(Register addr, Register newval, Register cmpval); diff --git a/src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp b/src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp index 957c2aee1c1..2b506b241e0 100644 --- a/src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp @@ -240,15 +240,14 @@ void InterpreterMacroAssembler::load_resolved_klass_at_offset( // Rsub_klass: subklass // // Kills: -// r2, r5 +// r2 void InterpreterMacroAssembler::gen_subtype_check(Register Rsub_klass, Label& ok_is_subtype) { assert(Rsub_klass != r0, "r0 holds superklass"); assert(Rsub_klass != r2, "r2 holds 2ndary super array length"); - assert(Rsub_klass != r5, "r5 holds 2ndary super array scan ptr"); // Profile the not-null value's klass. - profile_typecheck(r2, Rsub_klass, r5); // blows r2, reloads r5 + profile_typecheck(r2, Rsub_klass); // blows r2 // Do the check. check_klass_subtype(Rsub_klass, r0, r2, ok_is_subtype); // blows r2 @@ -991,7 +990,6 @@ void InterpreterMacroAssembler::profile_final_call(Register mdp) { void InterpreterMacroAssembler::profile_virtual_call(Register receiver, Register mdp, - Register reg2, bool receiver_can_be_null) { if (ProfileInterpreter) { Label profile_continue; @@ -1009,7 +1007,7 @@ void InterpreterMacroAssembler::profile_virtual_call(Register receiver, } // Record the receiver type. - record_klass_in_profile(receiver, mdp, reg2); + profile_receiver_type(receiver, mdp, 0); bind(skip_receiver_profile); // The method data pointer needs to be updated to reflect the new target. @@ -1018,131 +1016,6 @@ void InterpreterMacroAssembler::profile_virtual_call(Register receiver, } } -// This routine creates a state machine for updating the multi-row -// type profile at a virtual call site (or other type-sensitive bytecode). -// The machine visits each row (of receiver/count) until the receiver type -// is found, or until it runs out of rows. At the same time, it remembers -// the location of the first empty row. (An empty row records null for its -// receiver, and can be allocated for a newly-observed receiver type.) -// Because there are two degrees of freedom in the state, a simple linear -// search will not work; it must be a decision tree. Hence this helper -// function is recursive, to generate the required tree structured code. -// It's the interpreter, so we are trading off code space for speed. -// See below for example code. -void InterpreterMacroAssembler::record_klass_in_profile_helper( - Register receiver, Register mdp, - Register reg2, int start_row, - Label& done) { - if (TypeProfileWidth == 0) { - increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); - } else { - record_item_in_profile_helper(receiver, mdp, reg2, 0, done, TypeProfileWidth, - &VirtualCallData::receiver_offset, &VirtualCallData::receiver_count_offset); - } -} - -void InterpreterMacroAssembler::record_item_in_profile_helper(Register item, Register mdp, - Register reg2, int start_row, Label& done, int total_rows, - OffsetFunction item_offset_fn, OffsetFunction item_count_offset_fn) { - int last_row = total_rows - 1; - assert(start_row <= last_row, "must be work left to do"); - // Test this row for both the item and for null. - // Take any of three different outcomes: - // 1. found item => increment count and goto done - // 2. found null => keep looking for case 1, maybe allocate this cell - // 3. found something else => keep looking for cases 1 and 2 - // Case 3 is handled by a recursive call. - for (int row = start_row; row <= last_row; row++) { - Label next_test; - bool test_for_null_also = (row == start_row); - - // See if the item is item[n]. - int item_offset = in_bytes(item_offset_fn(row)); - test_mdp_data_at(mdp, item_offset, item, - (test_for_null_also ? reg2 : noreg), - next_test); - // (Reg2 now contains the item from the CallData.) - - // The item is item[n]. Increment count[n]. - int count_offset = in_bytes(item_count_offset_fn(row)); - increment_mdp_data_at(mdp, count_offset); - b(done); - bind(next_test); - - if (test_for_null_also) { - Label found_null; - // Failed the equality check on item[n]... Test for null. - if (start_row == last_row) { - // The only thing left to do is handle the null case. - cbz(reg2, found_null); - // Item did not match any saved item and there is no empty row for it. - // Increment total counter to indicate polymorphic case. - increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); - b(done); - bind(found_null); - break; - } - // Since null is rare, make it be the branch-taken case. - cbz(reg2, found_null); - - // Put all the "Case 3" tests here. - record_item_in_profile_helper(item, mdp, reg2, start_row + 1, done, total_rows, - item_offset_fn, item_count_offset_fn); - - // Found a null. Keep searching for a matching item, - // but remember that this is an empty (unused) slot. - bind(found_null); - } - } - - // In the fall-through case, we found no matching item, but we - // observed the item[start_row] is null. - - // Fill in the item field and increment the count. - int item_offset = in_bytes(item_offset_fn(start_row)); - set_mdp_data_at(mdp, item_offset, item); - int count_offset = in_bytes(item_count_offset_fn(start_row)); - mov(reg2, DataLayout::counter_increment); - set_mdp_data_at(mdp, count_offset, reg2); - if (start_row > 0) { - b(done); - } -} - -// Example state machine code for three profile rows: -// // main copy of decision tree, rooted at row[1] -// if (row[0].rec == rec) { row[0].incr(); goto done; } -// if (row[0].rec != nullptr) { -// // inner copy of decision tree, rooted at row[1] -// if (row[1].rec == rec) { row[1].incr(); goto done; } -// if (row[1].rec != nullptr) { -// // degenerate decision tree, rooted at row[2] -// if (row[2].rec == rec) { row[2].incr(); goto done; } -// if (row[2].rec != nullptr) { count.incr(); goto done; } // overflow -// row[2].init(rec); goto done; -// } else { -// // remember row[1] is empty -// if (row[2].rec == rec) { row[2].incr(); goto done; } -// row[1].init(rec); goto done; -// } -// } else { -// // remember row[0] is empty -// if (row[1].rec == rec) { row[1].incr(); goto done; } -// if (row[2].rec == rec) { row[2].incr(); goto done; } -// row[0].init(rec); goto done; -// } -// done: - -void InterpreterMacroAssembler::record_klass_in_profile(Register receiver, - Register mdp, Register reg2) { - assert(ProfileInterpreter, "must be profiling"); - Label done; - - record_klass_in_profile_helper(receiver, mdp, reg2, 0, done); - - bind (done); -} - void InterpreterMacroAssembler::profile_ret(Register return_bci, Register mdp) { if (ProfileInterpreter) { @@ -1200,7 +1073,7 @@ void InterpreterMacroAssembler::profile_null_seen(Register mdp) { } } -void InterpreterMacroAssembler::profile_typecheck(Register mdp, Register klass, Register reg2) { +void InterpreterMacroAssembler::profile_typecheck(Register mdp, Register klass) { if (ProfileInterpreter) { Label profile_continue; @@ -1213,7 +1086,7 @@ void InterpreterMacroAssembler::profile_typecheck(Register mdp, Register klass, mdp_delta = in_bytes(VirtualCallData::virtual_call_data_size()); // Record the object type. - record_klass_in_profile(klass, mdp, reg2); + profile_receiver_type(klass, mdp, 0); } update_mdp_by_constant(mdp, mdp_delta); diff --git a/src/hotspot/cpu/aarch64/interp_masm_aarch64.hpp b/src/hotspot/cpu/aarch64/interp_masm_aarch64.hpp index 2b230a3b73e..74d4430000d 100644 --- a/src/hotspot/cpu/aarch64/interp_masm_aarch64.hpp +++ b/src/hotspot/cpu/aarch64/interp_masm_aarch64.hpp @@ -273,15 +273,6 @@ class InterpreterMacroAssembler: public MacroAssembler { Register test_value_out, Label& not_equal_continue); - void record_klass_in_profile(Register receiver, Register mdp, - Register reg2); - void record_klass_in_profile_helper(Register receiver, Register mdp, - Register reg2, int start_row, - Label& done); - void record_item_in_profile_helper(Register item, Register mdp, - Register reg2, int start_row, Label& done, int total_rows, - OffsetFunction item_offset_fn, OffsetFunction item_count_offset_fn); - void update_mdp_by_offset(Register mdp_in, int offset_of_offset); void update_mdp_by_offset(Register mdp_in, Register reg, int offset_of_disp); void update_mdp_by_constant(Register mdp_in, int constant); @@ -295,11 +286,10 @@ class InterpreterMacroAssembler: public MacroAssembler { void profile_call(Register mdp); void profile_final_call(Register mdp); void profile_virtual_call(Register receiver, Register mdp, - Register scratch2, bool receiver_can_be_null = false); void profile_ret(Register return_bci, Register mdp); void profile_null_seen(Register mdp); - void profile_typecheck(Register mdp, Register klass, Register scratch); + void profile_typecheck(Register mdp, Register klass); void profile_typecheck_failed(Register mdp); void profile_switch_default(Register mdp); void profile_switch_case(Register index_in_scratch, Register mdp, diff --git a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp index e813a70372b..f8b5a6f825c 100644 --- a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp @@ -2118,6 +2118,161 @@ Address MacroAssembler::argument_address(RegisterOrConstant arg_slot, } } +// Handle the receiver type profile update given the "recv" klass. +// +// Normally updates the ReceiverData (RD) that starts at "mdp" + "mdp_offset". +// If there are no matching or claimable receiver entries in RD, updates +// the polymorphic counter. +// +// This code expected to run by either the interpreter or JIT-ed code, without +// extra synchronization. For safety, receiver cells are claimed atomically, which +// avoids grossly misrepresenting the profiles under concurrent updates. For speed, +// counter updates are not atomic. +// +void MacroAssembler::profile_receiver_type(Register recv, Register mdp, int mdp_offset) { + assert_different_registers(recv, mdp, rscratch1, rscratch2); + + int base_receiver_offset = in_bytes(ReceiverTypeData::receiver_offset(0)); + int end_receiver_offset = in_bytes(ReceiverTypeData::receiver_offset(ReceiverTypeData::row_limit())); + int poly_count_offset = in_bytes(CounterData::count_offset()); + int receiver_step = in_bytes(ReceiverTypeData::receiver_offset(1)) - base_receiver_offset; + int receiver_to_count_step = in_bytes(ReceiverTypeData::receiver_count_offset(0)) - base_receiver_offset; + + // Adjust for MDP offsets. + base_receiver_offset += mdp_offset; + end_receiver_offset += mdp_offset; + poly_count_offset += mdp_offset; + +#ifdef ASSERT + // We are about to walk the MDO slots without asking for offsets. + // Check that our math hits all the right spots. + for (uint c = 0; c < ReceiverTypeData::row_limit(); c++) { + int real_recv_offset = mdp_offset + in_bytes(ReceiverTypeData::receiver_offset(c)); + int real_count_offset = mdp_offset + in_bytes(ReceiverTypeData::receiver_count_offset(c)); + int offset = base_receiver_offset + receiver_step*c; + int count_offset = offset + receiver_to_count_step; + assert(offset == real_recv_offset, "receiver slot math"); + assert(count_offset == real_count_offset, "receiver count math"); + } + int real_poly_count_offset = mdp_offset + in_bytes(CounterData::count_offset()); + assert(poly_count_offset == real_poly_count_offset, "poly counter math"); +#endif + + // Corner case: no profile table. Increment poly counter and exit. + if (ReceiverTypeData::row_limit() == 0) { + increment(Address(mdp, poly_count_offset), DataLayout::counter_increment); + return; + } + + Register offset = rscratch2; + + Label L_loop_search_receiver, L_loop_search_empty; + Label L_restart, L_found_recv, L_found_empty, L_polymorphic, L_count_update; + + // The code here recognizes three major cases: + // A. Fastest: receiver found in the table + // B. Fast: no receiver in the table, and the table is full + // C. Slow: no receiver in the table, free slots in the table + // + // The case A performance is most important, as perfectly-behaved code would end up + // there, especially with larger TypeProfileWidth. The case B performance is + // important as well, this is where bulk of code would land for normally megamorphic + // cases. The case C performance is not essential, its job is to deal with installation + // races, we optimize for code density instead. Case C needs to make sure that receiver + // rows are only claimed once. This makes sure we never overwrite a row for another + // receiver and never duplicate the receivers in the list, making profile type-accurate. + // + // It is very tempting to handle these cases in a single loop, and claim the first slot + // without checking the rest of the table. But, profiling code should tolerate free slots + // in the table, as class unloading can clear them. After such cleanup, the receiver + // we need might be _after_ the free slot. Therefore, we need to let at least full scan + // to complete, before trying to install new slots. Splitting the code in several tight + // loops also helpfully optimizes for cases A and B. + // + // This code is effectively: + // + // restart: + // // Fastest: receiver is already installed + // for (i = 0; i < receiver_count(); i++) { + // if (receiver(i) == recv) goto found_recv(i); + // } + // + // // Fast: no receiver, but profile is full + // for (i = 0; i < receiver_count(); i++) { + // if (receiver(i) == null) goto found_null(i); + // } + // goto polymorphic + // + // // Slow: try to install receiver + // found_null(i): + // CAS(&receiver(i), null, recv); + // goto restart + // + // polymorphic: + // count++; + // return + // + // found_recv(i): + // *receiver_count(i)++ + // + + bind(L_restart); + + // Fastest: receiver is already installed + mov(offset, base_receiver_offset); + bind(L_loop_search_receiver); + ldr(rscratch1, Address(mdp, offset)); + cmp(rscratch1, recv); + br(Assembler::EQ, L_found_recv); + add(offset, offset, receiver_step); + sub(rscratch1, offset, end_receiver_offset); + cbnz(rscratch1, L_loop_search_receiver); + + // Fast: no receiver, but profile is full + mov(offset, base_receiver_offset); + bind(L_loop_search_empty); + ldr(rscratch1, Address(mdp, offset)); + cbz(rscratch1, L_found_empty); + add(offset, offset, receiver_step); + sub(rscratch1, offset, end_receiver_offset); + cbnz(rscratch1, L_loop_search_empty); + b(L_polymorphic); + + // Slow: try to install receiver + bind(L_found_empty); + + // Atomically swing receiver slot: null -> recv. + // + // The update uses CAS, which clobbers rscratch1. Therefore, rscratch2 + // is used to hold the destination address. This is safe because the + // offset is no longer needed after the address is computed. + + lea(rscratch2, Address(mdp, offset)); + cmpxchg(/*addr*/ rscratch2, /*expected*/ zr, /*new*/ recv, Assembler::xword, + /*acquire*/ false, /*release*/ false, /*weak*/ true, noreg); + + // CAS success means the slot now has the receiver we want. CAS failure means + // something had claimed the slot concurrently: it can be the same receiver we want, + // or something else. Since this is a slow path, we can optimize for code density, + // and just restart the search from the beginning. + b(L_restart); + + // Counter updates: + + // Increment polymorphic counter instead of receiver slot. + bind(L_polymorphic); + mov(offset, poly_count_offset); + b(L_count_update); + + // Found a receiver, convert its slot offset to corresponding count offset. + bind(L_found_recv); + add(offset, offset, receiver_to_count_step); + + bind(L_count_update); + increment(Address(mdp, offset), DataLayout::counter_increment); +} + + void MacroAssembler::call_VM_leaf_base(address entry_point, int number_of_arguments, Label *retaddr) { diff --git a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp index 4baa07d7d49..7eb6cea0614 100644 --- a/src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp +++ b/src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp @@ -1122,6 +1122,8 @@ public: Address argument_address(RegisterOrConstant arg_slot, int extra_slot_offset = 0); + void profile_receiver_type(Register recv, Register mdp, int mdp_offset); + void verify_sve_vector_length(Register tmp = rscratch1); void reinitialize_ptrue() { if (UseSVE > 0) { diff --git a/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp b/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp index 07b469650f0..5d4f7103a84 100644 --- a/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp @@ -3370,7 +3370,7 @@ void TemplateTable::invokevirtual_helper(Register index, __ load_klass(r0, recv); // profile this call - __ profile_virtual_call(r0, rlocals, r3); + __ profile_virtual_call(r0, rlocals); // get target Method & entry point __ lookup_virtual_method(r0, index, method); @@ -3500,7 +3500,7 @@ void TemplateTable::invokeinterface(int byte_no) { /*return_method=*/false); // profile this call - __ profile_virtual_call(r3, r13, r19); + __ profile_virtual_call(r3, r13); // Get declaring interface class from method, and itable index From 6afc0d8f39390d474ce8ba16533c30b4c7770388 Mon Sep 17 00:00:00 2001 From: Saranya Natarajan Date: Wed, 28 Jan 2026 09:38:20 +0000 Subject: [PATCH 088/105] 8366861: Phase AFTER_LOOP_OPTS printed even though the method has no loops Reviewed-by: chagedorn, dfenacci --- src/hotspot/share/opto/compile.cpp | 5 +++-- src/hotspot/share/opto/compile.hpp | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp index 7d99f4a7336..eaec1605108 100644 --- a/src/hotspot/share/opto/compile.cpp +++ b/src/hotspot/share/opto/compile.cpp @@ -1876,7 +1876,7 @@ void Compile::process_for_post_loop_opts_igvn(PhaseIterGVN& igvn) { // at least to this point, even if no loop optimizations were done. PhaseIdealLoop::verify(igvn); - if (has_loops() || _loop_opts_cnt > 0) { + if (_print_phase_loop_opts) { print_method(PHASE_AFTER_LOOP_OPTS, 2); } C->set_post_loop_opts_phase(); // no more loop opts allowed @@ -2404,7 +2404,8 @@ void Compile::Optimize() { if (failing()) return; - if (has_loops()) { + _print_phase_loop_opts = has_loops(); + if (_print_phase_loop_opts) { print_method(PHASE_BEFORE_LOOP_OPTS, 2); } diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp index 12812424f5e..d9a8ea15724 100644 --- a/src/hotspot/share/opto/compile.hpp +++ b/src/hotspot/share/opto/compile.hpp @@ -355,6 +355,7 @@ class Compile : public Phase { bool _print_assembly; // True if we should dump assembly code for this compilation bool _print_inlining; // True if we should print inlining for this compilation bool _print_intrinsics; // True if we should print intrinsics for this compilation + bool _print_phase_loop_opts; // True if we should print before and after loop opts phase #ifndef PRODUCT uint _phase_counter; // Counter for the number of already printed phases uint _igv_idx; // Counter for IGV node identifiers From 127bfc9b0dd122c78e702867a88e0847ec362e68 Mon Sep 17 00:00:00 2001 From: Yasumasa Suenaga Date: Wed, 28 Jan 2026 11:11:07 +0000 Subject: [PATCH 089/105] 8374926: EnableX86ECoreOpts was not enabled on some hybrid CPU Reviewed-by: vpaprotski, dholmes --- src/hotspot/cpu/x86/vm_version_x86.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/hotspot/cpu/x86/vm_version_x86.cpp b/src/hotspot/cpu/x86/vm_version_x86.cpp index 747daefd51d..0fff5b44e00 100644 --- a/src/hotspot/cpu/x86/vm_version_x86.cpp +++ b/src/hotspot/cpu/x86/vm_version_x86.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -921,8 +921,9 @@ void VM_Version::get_processor_features() { // Check if processor has Intel Ecore if (FLAG_IS_DEFAULT(EnableX86ECoreOpts) && is_intel() && is_intel_server_family() && - (_model == 0x97 || _model == 0xAA || _model == 0xAC || _model == 0xAF || - _model == 0xCC || _model == 0xDD)) { + (supports_hybrid() || + _model == 0xAF /* Xeon 6 E-cores (Sierra Forest) */ || + _model == 0xDD /* Xeon 6+ E-cores (Clearwater Forest) */ )) { FLAG_SET_DEFAULT(EnableX86ECoreOpts, true); } From 2a465cb0eba6ffe397cf3ad8c1def06bf7a1e392 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20H=C3=BCbner?= Date: Wed, 28 Jan 2026 13:14:51 +0000 Subject: [PATCH 090/105] 8371777: Clean up preferred address of G1's archive region Reviewed-by: stefank, jsikstro --- src/hotspot/share/cds/aotMappedHeapLoader.cpp | 2 +- src/hotspot/share/gc/g1/g1CollectedHeap.cpp | 2 +- src/hotspot/share/gc/g1/g1CollectedHeap.hpp | 6 ++---- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/hotspot/share/cds/aotMappedHeapLoader.cpp b/src/hotspot/share/cds/aotMappedHeapLoader.cpp index 84051cbd9e5..a8678ed757f 100644 --- a/src/hotspot/share/cds/aotMappedHeapLoader.cpp +++ b/src/hotspot/share/cds/aotMappedHeapLoader.cpp @@ -619,7 +619,7 @@ bool AOTMappedHeapLoader::map_heap_region_impl(FileMapInfo* info) { aot_log_info(aot)("Preferred address to map heap data (to avoid relocation) is " INTPTR_FORMAT, p2i(requested_start)); // allocate from java heap - HeapWord* start = G1CollectedHeap::heap()->alloc_archive_region(word_size, (HeapWord*)requested_start); + HeapWord* start = G1CollectedHeap::heap()->alloc_archive_region(word_size); if (start == nullptr) { AOTMetaspace::report_loading_error("UseSharedSpaces: Unable to allocate java heap region for archive heap."); return false; diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp index b6c3c0b0907..8f83a653885 100644 --- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp +++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp @@ -525,7 +525,7 @@ void G1CollectedHeap::iterate_regions_in_range(MemRegion range, const Func& func } } -HeapWord* G1CollectedHeap::alloc_archive_region(size_t word_size, HeapWord* preferred_addr) { +HeapWord* G1CollectedHeap::alloc_archive_region(size_t word_size) { assert(!is_init_completed(), "Expect to be called at JVM init time"); MutexLocker x(Heap_lock); diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp index 8009df1fa6a..1f900c76851 100644 --- a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp +++ b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp @@ -736,12 +736,10 @@ public: void iterate_regions_in_range(MemRegion range, const Func& func); // Commit the required number of G1 region(s) according to the size requested - // and mark them as 'old' region(s). Preferred address is treated as a hint for - // the location of the archive space in the heap. The returned address may or may - // not be same as the preferred address. + // and mark them as 'old' region(s). // This API is only used for allocating heap space for the archived heap objects // in the CDS archive. - HeapWord* alloc_archive_region(size_t word_size, HeapWord* preferred_addr); + HeapWord* alloc_archive_region(size_t word_size); // Populate the G1BlockOffsetTable for archived regions with the given // memory range. From 8c86b1bb1054b565cf23156d89ee8925a4e32597 Mon Sep 17 00:00:00 2001 From: Roger Calnan Date: Wed, 28 Jan 2026 14:18:52 +0000 Subject: [PATCH 091/105] 8375325: add anchors to the options in the security man pages Reviewed-by: weijun, hchao --- src/java.base/share/man/keytool.md | 58 ++++++++++----------- src/java.security.jgss/windows/man/kinit.md | 20 +++---- src/java.security.jgss/windows/man/klist.md | 6 +-- src/java.security.jgss/windows/man/ktab.md | 10 ++-- src/jdk.jartool/share/man/jarsigner.md | 54 +++++++++---------- 5 files changed, 74 insertions(+), 74 deletions(-) diff --git a/src/java.base/share/man/keytool.md b/src/java.base/share/man/keytool.md index 19ba8c34912..1d70bd2f5f8 100644 --- a/src/java.base/share/man/keytool.md +++ b/src/java.base/share/man/keytool.md @@ -1,5 +1,5 @@ --- -# Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1998, 2026, 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 @@ -211,7 +211,7 @@ perform. ## Commands for Creating or Adding Data to the Keystore -`-gencert` +[`-gencert`]{#command-gencert} : The following are the available options for the `-gencert` command: - {`-rfc`}: Output in RFC (Request For Comment) style @@ -328,7 +328,7 @@ perform. > `keytool -alias e1 -certreq | keytool -alias ca2 -gencert > e1.cert` -`-genkeypair` +[`-genkeypair`]{#option-genkeypair} : The following are the available options for the `-genkeypair` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -478,7 +478,7 @@ perform. specified by `-startdate`, or the current date when `-startdate` isn't specified) for which the certificate should be considered valid. -`-genseckey` +[`-genseckey`]{#command-genseckey} : The following are the available options for the `-genseckey` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -521,7 +521,7 @@ perform. the same password that is used for the `-keystore`. The `-keypass` value must contain at least six characters. -`-importcert` +[`-importcert`]{#command-importcert} : The following are the available options for the `-importcert` command: - {`-noprompt`}: Do not prompt @@ -586,7 +586,7 @@ perform. entry, then the `keytool` command assumes that you're importing a certificate reply. -`-importpass` +[`-importpass`]{#command-importpass} : The following are the available options for the `-importpass` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -629,7 +629,7 @@ perform. ## Commands for Importing Contents from Another Keystore -`-importkeystore` +[`-importkeystore`]{#command-importkeystore} : The following are the available options for the `-importkeystore` command: - `-srckeystore` *keystore*: Source keystore name @@ -724,7 +724,7 @@ perform. ## Commands for Generating a Certificate Request -`-certreq` +[`-certreq`]{#command-certreq} : The following are the available options for the `-certreq` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -786,7 +786,7 @@ perform. ## Commands for Exporting Data -`-exportcert` +[`-exportcert`]{#command-exportcert} : The following are the available options for the `-exportcert` command: - {`-rfc`}: Output in RFC style @@ -834,7 +834,7 @@ perform. ## Commands for Displaying Data -`-list` +[`-list`]{#command-list} : The following are the available options for the `-list` command: - {`-rfc`}: Output in RFC style @@ -881,7 +881,7 @@ perform. You can't specify both `-v` and `-rfc` in the same command. Otherwise, an error is reported. -`-printcert` +[`-printcert`]{#command-printcert} : The following are the available options for the `-printcert` command: - {`-rfc`}: Output in RFC style @@ -946,7 +946,7 @@ perform. trusted certificate in the user keystore (specified by `-keystore`) or in the `cacerts` keystore (if `-trustcacerts` is specified). -`-printcertreq` +[`-printcertreq`]{#command-printcertreq} : The following are the available options for the `-printcertreq` command: - {`-file` *file*}: Input file name @@ -958,7 +958,7 @@ perform. command. The command reads the request from file. If there is no file, then the request is read from the standard input. -`-printcrl` +[`-printcrl`]{#command-printcrl} : The following are the available options for the `-printcrl` command: - {`-file crl`}: Input file name @@ -999,7 +999,7 @@ perform. ## Commands for Managing the Keystore -`-storepasswd` +[`-storepasswd`]{#command-storepasswd} : The following are the available options for the `-storepasswd` command: - \[`-new` *arg*\]: New password @@ -1029,7 +1029,7 @@ perform. integrity of the keystore contents. The new password is set by `-new` *arg* and must contain at least six characters. -`-keypasswd` +[`-keypasswd`]{#command-keypasswd} : The following are the available options for the `-keypasswd` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -1069,7 +1069,7 @@ perform. If the `-new` option isn't provided at the command line, then the user is prompted for it. -`-delete` +[`-delete`]{#command-delete} : The following are the available options for the `-delete` command: - \[`-alias` *alias*\]: Alias name of the entry to process @@ -1101,7 +1101,7 @@ perform. keystore. When not provided at the command line, the user is prompted for the `alias`. -`-changealias` +[`-changealias`]{#command-changealias} : The following are the available options for the `-changealias` command: - {`-alias` *alias*}: Alias name of the entry to process @@ -1143,7 +1143,7 @@ perform. ## Commands for Displaying Security-related Information -`-showinfo` +[`-showinfo`]{#command-showinfo} : The following are the available options for the `-showinfo` command: - {`-tls`}: Displays TLS configuration information @@ -1185,10 +1185,10 @@ environment or memory usage. For a list of possible interpreter options, enter These options can appear for all commands operating on a keystore: -`-storetype` *storetype* +[`-storetype`]{#option-storetype} *storetype* : This qualifier specifies the type of keystore to be instantiated. -`-keystore` *keystore* +[`-keystore`]{#option-keystore} *keystore* : The keystore location. If the JKS `storetype` is used and a keystore file doesn't yet exist, then @@ -1206,13 +1206,13 @@ These options can appear for all commands operating on a keystore: if the keystore isn't file-based. For example, when the keystore resides on a hardware token device. -`-cacerts` *cacerts* +[`-cacerts`]{#option-cacerts} *cacerts* : Operates on the *cacerts* keystore . This option is equivalent to `-keystore` *path\_to\_cacerts* `-storetype` *type\_of\_cacerts*. An error is reported if the `-keystore` or `-storetype` option is used with the `-cacerts` option. -`-storepass` \[`:env` \| `:file` \] *argument* +[`-storepass`]{#option-storepass} \[`:env` \| `:file` \] *argument* : The password that is used to protect the integrity of the keystore. If the modifier `env` or `file` isn't specified, then the password has the @@ -1237,22 +1237,22 @@ These options can appear for all commands operating on a keystore: a password is not specified, then the integrity of the retrieved information can't be verified and a warning is displayed. -`-providername` *name* +[`-providername`]{#option-providername} *name* : Used to identify a cryptographic service provider's name when listed in the security properties file. -`-addprovider` *name* +[`-addprovider`]{#option-addprovider} *name* : Used to add a security provider by name (such as SunPKCS11) . -`-providerclass` *class* +[`-providerclass`]{#option-providerclass} *class* : Used to specify the name of a cryptographic service provider's master class file when the service provider isn't listed in the security properties file. -`-providerpath` *list* +[`-providerpath`]{#option-providerpath} *list* : Used to specify the provider classpath. -`-providerarg` *arg* +[`-providerarg`]{#option-providerarg} *arg* : Used with the `-addprovider` or `-providerclass` option to represent an optional string input argument for the constructor of *class* name. @@ -1263,7 +1263,7 @@ These options can appear for all commands operating on a keystore: following two options, `-srcprotected` and `-destprotected`, are provided for the source keystore and the destination keystore respectively. -`-ext` {*name*{`:critical`} {`=`*value*}} +[`-ext`]{#option-ext} {*name*{`:critical`} {`=`*value*}} : Denotes an X.509 certificate extension. The option can be used in `-genkeypair` and `-gencert` to embed extensions into the generated certificate, or in `-certreq` to show what extensions are requested in the @@ -1276,7 +1276,7 @@ These options can appear for all commands operating on a keystore: `isCritical` attribute is `true`; otherwise, it is `false`. You can use `:c` in place of `:critical`. -`-conf` *file* +[`-conf`]{#option-conf} *file* : Specifies a pre-configured options file. ## Pre-configured options file diff --git a/src/java.security.jgss/windows/man/kinit.md b/src/java.security.jgss/windows/man/kinit.md index 130bf7b007a..a32d6634e74 100644 --- a/src/java.security.jgss/windows/man/kinit.md +++ b/src/java.security.jgss/windows/man/kinit.md @@ -1,5 +1,5 @@ --- -# Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2005, 2026, 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 @@ -79,34 +79,34 @@ will compromise your password. You can specify one of the following commands. After the command, specify the options for it. -`-A` +[`-A`]{#option-A} : Doesn't include addresses. -`-f` +[`-f`]{#option-f} : Issues a forwardable ticket. -`-p` +[`-p`]{#option-p} : Issues a proxiable ticket. -`-c` *cache\_name* +[`-c`]{#option-c} *cache\_name* : The cache name (for example, `FILE:D:\temp\mykrb5cc`). -`-l` *lifetime* +[`-l`]{#option-l} *lifetime* : Sets the lifetime of a ticket. The value can be one of "h:m[:s]", "NdNhNmNs", and "N". See the [MIT krb5 Time Duration definition]( http://web.mit.edu/kerberos/krb5-1.17/doc/basic/date_format.html#duration) for more information. -`-r` *renewable\_time* +[`-r`]{#option-r} *renewable\_time* : Sets the total lifetime that a ticket can be renewed. -`-R` +[`-R`]{#option-R} : Renews a ticket. -`-k` +[`-k`]{#option-k} : Uses keytab -`-t` *keytab\_filename* +[`-t`]{#option-t} *keytab\_filename* : The keytab name (for example, `D:\winnt\profiles\duke\krb5.keytab`). *principal* diff --git a/src/java.security.jgss/windows/man/klist.md b/src/java.security.jgss/windows/man/klist.md index 67c84e65dec..c4874f7dc67 100644 --- a/src/java.security.jgss/windows/man/klist.md +++ b/src/java.security.jgss/windows/man/klist.md @@ -1,5 +1,5 @@ --- -# Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2005, 2026, 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 @@ -45,7 +45,7 @@ the contents of the credentials cache or keytab using the `klist` tool. The ## Commands -`-c` +[`-c`]{#option-c} : Specifies that the credential cache is to be listed. The following are the options for credential cache entries: @@ -62,7 +62,7 @@ the contents of the credentials cache or keytab using the `klist` tool. The `-n` : If the `-a` option is specified, don't reverse resolve addresses. -`-k` +[`-k`]{#option-k} : Specifies that key tab is to be listed. List the keytab entries. The following are the options for keytab entries: diff --git a/src/java.security.jgss/windows/man/ktab.md b/src/java.security.jgss/windows/man/ktab.md index d6817ab81cf..36e09d56e3e 100644 --- a/src/java.security.jgss/windows/man/ktab.md +++ b/src/java.security.jgss/windows/man/ktab.md @@ -1,5 +1,5 @@ --- -# Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2005, 2026, 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 @@ -72,12 +72,12 @@ send a keytab file over a network in the clear. ## Commands and Options -`-l` \[`-e`\] \[`-t`\] +[`-l`]{#command-l} \[`-e`\] \[`-t`\] : Lists the keytab name and entries. When `-e` is specified, the encryption type for each entry is displayed. When `-t` is specified, the timestamp for each entry is displayed. -`-a` *principal\_name* \[*password*\] \[`-n` *kvno*\] \[`-s` *salt* \| `-f`\] \[`-append`\] +[`-a`]{#command-a} *principal\_name* \[*password*\] \[`-n` *kvno*\] \[`-s` *salt* \| `-f`\] \[`-append`\] : Adds new key entries to the keytab for the given principal name with an optional *password*. If a *kvno* is specified, new keys' Key Version Numbers equal to the value, otherwise, automatically incrementing the Key @@ -90,7 +90,7 @@ send a keytab file over a network in the clear. on the command line or in a script.** This tool will prompt for a password if it isn't specified. -`-d` *principal\_name* \[`-f`\] \[`-e` *etype*\] \[*kvno* \| `all`\| `old`\] +[`-d`]{#command-d} *principal\_name* \[`-f`\] \[`-e` *etype*\] \[*kvno* \| `all`\| `old`\] : Deletes key entries from the keytab for the specified principal. No changes are made to the Kerberos database. @@ -115,7 +115,7 @@ send a keytab file over a network in the clear. This option can be used with the `-l`, `-a` or `-d` commands. -`-k` *keytab name* +[`-k`]{#option-k} *keytab name* : Specifies the keytab name and path with the `FILE:` prefix. ## Examples diff --git a/src/jdk.jartool/share/man/jarsigner.md b/src/jdk.jartool/share/man/jarsigner.md index 0ecc159a037..d128b9c11ff 100644 --- a/src/jdk.jartool/share/man/jarsigner.md +++ b/src/jdk.jartool/share/man/jarsigner.md @@ -483,7 +483,7 @@ the following standards: `-keystore` option is relevant for signing and verifying a JAR file. In addition, aliases are specified when signing and verifying a JAR file. -`-keystore` *url* +[`-keystore`]{#option-keystore} *url* : Specifies the URL that tells the keystore location. This defaults to the file `.keystore` in the user's home directory, as determined by the `user.home` system property. @@ -517,7 +517,7 @@ the following standards: > `keytool -keystore NONE -storetype PKCS11 -list` -`-storepass` \[`:env` \| `:file`\] *argument* +[`-storepass`]{#option-storepass} \[`:env` \| `:file`\] *argument* : Specifies the password that is required to access the keystore. This is only needed when signing (not verifying) a JAR file. In that case, if a `-storepass` option isn't provided at the command line, then the user is @@ -536,7 +536,7 @@ the following standards: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system. -`-storetype` *storetype* +[`-storetype`]{#option-storetype} *storetype* : Specifies the type of keystore to be instantiated. The default keystore type is the one that is specified as the value of the `keystore.type` property in the security properties file, which is returned by the static @@ -548,7 +548,7 @@ the following standards: (such as a dedicated PIN-pad or a biometric reader), then the `-protected` option must be specified and no password options can be specified. -`-keypass` \[`:env` \| `:file`\] *argument* `-certchain` *file* +[`-keypass`]{#option-keypass} \[`:env` \| `:file`\] *argument* `-certchain` *file* : Specifies the password used to protect the private key of the keystore entry addressed by the alias specified on the command line. The password is required when using `jarsigner` to sign a JAR file. If no password is @@ -568,7 +568,7 @@ the following standards: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system. -`-certchain` *file* +[`-certchain`]{#option-certchain} *file* : Specifies the certificate chain to be used when the certificate chain associated with the private key of the keystore entry that is addressed by the alias specified on the command line isn't complete. This can happen @@ -579,7 +579,7 @@ the following standards: (also known as Base64 encoding) as defined by [Internet RFC 1421 Certificate Encoding Standard](http://tools.ietf.org/html/rfc1421). -`-sigfile` *file* +[`-sigfile`]{#option-sigfile} *file* : Specifies the base file name to be used for the generated `.SF` and signature block files. For example, if file is `DUKESIGN`, then the generated `.SF` and signature block files are named `DUKESIGN.SF` and `DUKESIGN.RSA`, and placed in the @@ -598,10 +598,10 @@ the following standards: file name, then each such character is converted to an underscore (\_) character to form the file name. -`-signedjar` *file* +[`-signedjar`]{#option-signedjar} *file* : Specifies the name of signed JAR file. -`-digestalg` *algorithm* +[`-digestalg`]{#option-digestalg} *algorithm* : Specifies the name of the message digest algorithm to use when digesting the entries of a JAR file. @@ -613,7 +613,7 @@ the following standards: specified algorithm or the user must specify one with the `-addprovider` or `-providerClass` options; otherwise, the command will not succeed. -`-sigalg` *algorithm* +[`-sigalg`]{#option-sigalg} *algorithm* : Specifies the name of the signature algorithm to use to sign the JAR file. This algorithm must be compatible with the private key used to sign the @@ -627,10 +627,10 @@ the following standards: For a list of standard signature algorithm names, see the Java Security Standard Algorithm Names Specification. -`-verify` +[`-verify`]{#option-verify} : Verifies a signed JAR file. -`-verbose`\[`:`*suboptions*\] +[`-verbose`]{#option-verbose}\[`:`*suboptions*\] : When the `-verbose` option appears on the command line, it indicates that the `jarsigner` use the verbose mode when signing or verifying with the suboptions determining how much information is shown. This causes the , @@ -654,7 +654,7 @@ the following standards: more)*. See [Example of Verifying a Signed JAR File] and [Example of Verification with Certificate Information]. -`-certs` +[`-certs`]{#option-certs} : If the `-certs` option appears on the command line with the `-verify` and `-verbose` options, then the output includes certificate information for each signer of the JAR file. This information includes the name of the type @@ -669,14 +669,14 @@ the following standards: the alias name for the keystore entry for that signer is displayed in parentheses. -`-revCheck` +[`-revCheck`]{#option-revCheck} : This option enables revocation checking of certificates when signing or verifying a JAR file. The `jarsigner` command attempts to make network connections to fetch OCSP responses and CRLs if the `-revCheck` option is specified on the command line. Note that revocation checks are not enabled unless this option is specified. -`-tsa` *url* +[`-tsa`]{#option-tsa} *url* : If `-tsa http://example.tsa.url` appears on the command line when signing a JAR file then a time stamp is generated for the signature. The URL, `http://example.tsa.url`, identifies the location of the Time Stamping @@ -689,7 +689,7 @@ the following standards: stamp token returned by the TSA is stored with the signature in the signature block file. -`-tsacert` *alias* +[`-tsacert`]{#option-tsacert} *alias* : When `-tsacert` *alias* appears on the command line when signing a JAR file, a time stamp is generated for the signature. The alias identifies the TSA public key certificate in the keystore that is in effect. The entry's @@ -699,7 +699,7 @@ the following standards: The TSA public key certificate must be present in the keystore when using the `-tsacert` option. -`-tsapolicyid` *policyid* +[`-tsapolicyid`]{#option-tsapolicyid} *policyid* : Specifies the object identifier (OID) that identifies the policy ID to be sent to the TSA server. If this option isn't specified, no policy ID is sent and the TSA server will choose a default policy ID. @@ -708,7 +708,7 @@ the following standards: Standardization Sector (ITU-T) standard. These identifiers are typically period-separated sets of non-negative digits like `1.2.3.4`, for example. -`-tsadigestalg` *algorithm* +[`-tsadigestalg`]{#option-tsadigestalg} *algorithm* : Specifies the message digest algorithm that is used to generate the message imprint to be sent to the TSA server. If this option isn't specified, SHA-384 will be used. @@ -718,7 +718,7 @@ the following standards: For a list of standard message digest algorithm names, see the Java Security Standard Algorithm Names Specification. -`-internalsf` +[`-internalsf`]{#option-internalsf} : In the past, the signature block file generated when a JAR file was signed included a complete encoded copy of the `.SF` file (signature file) also generated. This behavior has been changed. To reduce the overall @@ -728,7 +728,7 @@ the following standards: In practice, don't use the `-internalsf` option because it incurs higher overhead. -`-sectionsonly` +[`-sectionsonly`]{#option-sectionsonly} : If the `-sectionsonly` option appears on the command line, then the `.SF` file (signature file) generated when a JAR file is signed doesn't include a header that contains a hash of the whole manifest file. It contains only @@ -747,12 +747,12 @@ the following standards: The `-sectionsonly` option is primarily used for testing. It shouldn't be used other than for testing because using it incurs higher overhead. -`-protected` +[`-protected`]{#option-protected} : Values can be either `true` or `false`. Specify `true` when a password must be specified through a protected authentication path such as a dedicated PIN reader. -`-providerName` *providerName* +[`-providerName`]{#option-providerName} *providerName* : If more than one provider was configured in the `java.security` security properties file, then you can use the `-providerName` option to target a specific provider instance. The argument to this option is the name of the @@ -768,7 +768,7 @@ the following standards: > `jarsigner -keystore NONE -storetype PKCS11 -providerName SunPKCS11-SmartCard -list` -`-addprovider` *name* \[`-providerArg` *arg*\] +[`-addprovider`]{#option-addprovider} *name* \[`-providerArg` *arg*\] : Adds a security provider by name (such as SunPKCS11) and an optional configure argument. The value of the security provider is the name of a security provider that is defined in a module. @@ -782,7 +782,7 @@ the following standards: > `jarsigner -keystore NONE -storetype PKCS11 -addprovider SunPKCS11 -providerArg /mydir1/mydir2/token.config` -`-providerClass` *provider-class-name* \[`-providerArg` *arg*\] +[`-providerClass`]{#option-providerClass} *provider-class-name* \[`-providerArg` *arg*\] : Used to specify the name of cryptographic service provider's master class file when the service provider isn't listed in the `java.security` security properties file. Adds a security provider by fully-qualified class name and @@ -792,7 +792,7 @@ the following standards: The preferred way to load PKCS11 is by using modules. See `-addprovider`. -`-providerPath` *classpath* +[`-providerPath`]{#option-providerPath} *classpath* : Used to specify the classpath for providers specified by the `-providerClass` option. Multiple paths should be separated by the system-dependent path-separator character. @@ -804,13 +804,13 @@ the following standards: execution environment or memory usage. For a list of possible interpreter options, type `java -h` or `java -X` at the command line. -`-strict` +[`-strict`]{#option-strict} : During the signing or verifying process, the command may issue warning messages. If you specify this option, the exit code of the tool reflects the severe warning messages that this command found. See [Errors and Warnings]. -`-conf` *url* +[`-conf`]{#option-conf} *url* : Specifies a pre-configured options file. Read the [keytool documentation](keytool.html#pre-configured-options-file) for details. The property keys supported are "jarsigner.all" for all actions, @@ -818,7 +818,7 @@ the following standards: `jarsigner` arguments including the JAR file name and alias name(s) cannot be set in this file. -`-version` +[`-version`]{#option-version} : Prints the program version. ## Errors and Warnings From 8095e33ee88759cf2fbe61e2284d95f6b7fb9a3a Mon Sep 17 00:00:00 2001 From: Christian Stein Date: Wed, 28 Jan 2026 15:02:21 +0000 Subject: [PATCH 092/105] 8375433: jar should validate automatic module names Reviewed-by: jvernee --- .../classes/sun/tools/jar/Validator.java | 35 +++++++++++- .../sun/tools/jar/resources/jar.properties | 4 ++ test/jdk/tools/jar/ValidatorTest.java | 53 ++++++++++++++++--- 3 files changed, 83 insertions(+), 9 deletions(-) diff --git a/src/jdk.jartool/share/classes/sun/tools/jar/Validator.java b/src/jdk.jartool/share/classes/sun/tools/jar/Validator.java index be694eeb1bc..c6f6f012543 100644 --- a/src/jdk.jartool/share/classes/sun/tools/jar/Validator.java +++ b/src/jdk.jartool/share/classes/sun/tools/jar/Validator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -47,6 +47,8 @@ import java.util.function.Function; import java.util.function.IntSupplier; import java.util.regex.Pattern; import java.util.stream.Collectors; +import java.util.jar.Attributes; +import java.util.jar.Manifest; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import java.util.zip.ZipInputStream; @@ -100,6 +102,7 @@ final class Validator { this.zf = zf; this.zis = zis; checkModuleDescriptor(MODULE_INFO); + checkAutomaticModuleName(); } static boolean validate(Main main, File zipFile) throws IOException { @@ -453,6 +456,36 @@ final class Validator { }); } + /** + * Checks whether an Automatic-Module-Name entry is valid + * and also verifies it to the name given by a compiled + * module descriptor. + */ + private void checkAutomaticModuleName() { + var entry = zf.getEntry("META-INF/MANIFEST.MF"); + if (entry == null) { + return; + } + try (InputStream jis = zf.getInputStream(entry)) { + Attributes attributes = new Manifest(jis).getMainAttributes(); + String automaticModuleName = attributes.getValue("Automatic-Module-Name"); + if (automaticModuleName == null) { + return; + } + try { + ModuleDescriptor.newAutomaticModule(automaticModuleName); + } catch (IllegalArgumentException e) { + errorAndInvalid(formatMsg("error.validator.manifest.invalid.automatic.module.name", automaticModuleName)); + } + if (md == null || automaticModuleName.equals(md.name())) { + return; + } + errorAndInvalid(formatMsg("error.validator.manifest.inconsistent.automatic.module.name", automaticModuleName, md.name())); + } catch (IOException e) { + errorAndInvalid(e.getMessage()); + } + } + /* * Checks whether or not the given versioned module descriptor's attributes * are valid when compared against the root/base module descriptor. diff --git a/src/jdk.jartool/share/classes/sun/tools/jar/resources/jar.properties b/src/jdk.jartool/share/classes/sun/tools/jar/resources/jar.properties index c80377e20c1..95c5f80197d 100644 --- a/src/jdk.jartool/share/classes/sun/tools/jar/resources/jar.properties +++ b/src/jdk.jartool/share/classes/sun/tools/jar/resources/jar.properties @@ -138,6 +138,10 @@ error.validator.metainf.wrong.position=\ expected entry META-INF/ to be at position 0, but found: {0} error.validator.manifest.wrong.position=\ expected entry META-INF/MANIFEST.MF to be at position 0 or 1, but found it at position: {0} +error.validator.manifest.invalid.automatic.module.name=\ + invalid module name of Automatic-Module-Name entry in manifest: {0} +error.validator.manifest.inconsistent.automatic.module.name=\ + expected Automatic-Module-Name entry in manifest: {0} to match name of compiled module: {1} warn.validator.identical.entry=\ Warning: entry {0} contains a class that\n\ is identical to an entry already in the jar diff --git a/test/jdk/tools/jar/ValidatorTest.java b/test/jdk/tools/jar/ValidatorTest.java index c2dfeae8dec..e3f649a04a2 100644 --- a/test/jdk/tools/jar/ValidatorTest.java +++ b/test/jdk/tools/jar/ValidatorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -23,12 +23,8 @@ /* * @test - * @bug 8345431 + * @bug 8345431 8375433 * @summary test validator to report malformed jar file - * @library /test/lib - * @modules jdk.jartool - * @build jdk.test.lib.Platform - * jdk.test.lib.util.FileUtils * @run junit/othervm ValidatorTest */ @@ -40,6 +36,7 @@ import org.junit.jupiter.api.TestInstance.Lifecycle; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertLinesMatch; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; @@ -59,13 +56,15 @@ import java.util.stream.Stream; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; -import jdk.test.lib.util.FileUtils; - class ValidatorTest { private static final ToolProvider JAR_TOOL = ToolProvider.findFirst("jar") .orElseThrow(() -> new RuntimeException("jar tool not found") ); + private static final ToolProvider JAVAC_TOOL = ToolProvider.findFirst("javac") + .orElseThrow(() -> + new RuntimeException("javac tool not found") + ); private final String nl = System.lineSeparator(); private final ByteArrayOutputStream baos = new ByteArrayOutputStream(); @@ -310,6 +309,44 @@ class ValidatorTest { } } + @Test + public void testInvalidAutomaticModuleName() throws Exception { + System.out.printf("%n%n*****Creating Jar with invalid Automatic-Module-Name in Manifest*****%n%n"); + var file = Path.of("InvalidAutomaticModuleName.jar"); + var manifest = Path.of("MANIFEST.MF"); + Files.writeString(manifest, + """ + Automatic-Module-Name: default + """); + jar("--create --file " + file + " --manifest " + manifest); + var e = assertThrows(IOException.class, () -> jar("--validate --file " + file.toString())); + var err = e.getMessage(); + System.out.println(err); + assertTrue(err.contains("invalid module name of Automatic-Module-Name entry in manifest: default"), "missing warning for: default"); + } + + @Test + public void testWrongAutomaticModuleName() throws Exception { + System.out.printf("%n%n*****Creating Jar with wrong Automatic-Module-Name in Manifest*****%n%n"); + var file = Path.of("WrongAutomaticModuleName.jar"); + var foo = Path.of("module-info.java"); + Files.writeString(foo, + """ + module foo {} + """); + var manifest = Path.of("MANIFEST.MF"); + Files.writeString(manifest, + """ + Automatic-Module-Name: bar + """); + JAVAC_TOOL.run(System.out, System.err, foo.toString()); + jar("--create --file " + file + " --manifest " + manifest + " module-info.class"); + var e = assertThrows(IOException.class, () -> jar("--validate --file " + file.toString())); + var err = e.getMessage(); + System.out.println(err); + assertTrue(err.contains("expected Automatic-Module-Name entry in manifest: bar to match name of compiled module: foo"), "missing warning for: foo/bar"); + } + /** * Validates that base manifest-related entries are at expected LOC positions. *

    From 0e2e66be2423335002a53d887df35d2348a3ec9f Mon Sep 17 00:00:00 2001 From: Matthias Baesken Date: Wed, 28 Jan 2026 16:30:34 +0000 Subject: [PATCH 093/105] 8376402: Dependencies::print_statistics() and AbstractClassHierarchyWalker::print_statistics() are not called from PRODUCT code Reviewed-by: azafari, chagedorn --- src/hotspot/share/code/dependencies.cpp | 6 ++++-- src/hotspot/share/code/dependencies.hpp | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/hotspot/share/code/dependencies.cpp b/src/hotspot/share/code/dependencies.cpp index d90695739a1..dbfe1cd884e 100644 --- a/src/hotspot/share/code/dependencies.cpp +++ b/src/hotspot/share/code/dependencies.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2026, 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 @@ -1124,7 +1124,7 @@ class AbstractClassHierarchyWalker { Klass* find_witness(InstanceKlass* context_type, KlassDepChange* changes = nullptr); static void init(); - static void print_statistics(); + NOT_PRODUCT(static void print_statistics();) }; PerfCounter* AbstractClassHierarchyWalker::_perf_find_witness_anywhere_calls_count = nullptr; @@ -2277,6 +2277,7 @@ bool KlassDepChange::involves_context(Klass* k) { return is_contained; } +#ifndef PRODUCT void Dependencies::print_statistics() { AbstractClassHierarchyWalker::print_statistics(); } @@ -2302,6 +2303,7 @@ void AbstractClassHierarchyWalker::print_statistics() { } } } +#endif CallSiteDepChange::CallSiteDepChange(Handle call_site, Handle method_handle) : _call_site(call_site), diff --git a/src/hotspot/share/code/dependencies.hpp b/src/hotspot/share/code/dependencies.hpp index d11c51a66dc..582a08183f9 100644 --- a/src/hotspot/share/code/dependencies.hpp +++ b/src/hotspot/share/code/dependencies.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2026, 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 @@ -649,7 +649,7 @@ class Dependencies: public ResourceObj { }; friend class Dependencies::DepStream; - static void print_statistics(); + NOT_PRODUCT(static void print_statistics();) }; From 50d872ad7ac5fa5a3406517eb53d8f61f81706df Mon Sep 17 00:00:00 2001 From: Brian Burkhalter Date: Wed, 28 Jan 2026 16:30:56 +0000 Subject: [PATCH 094/105] 8376419: (fs) Minor improvement of java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java Reviewed-by: jpai --- .../UserDefinedFileAttributeView/Basic.java | 22 +++++++++++-------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/test/jdk/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java b/test/jdk/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java index 4586c33521f..b729438812f 100644 --- a/test/jdk/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java +++ b/test/jdk/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, 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 @@ -24,9 +24,12 @@ /* @test * @bug 4313887 6838333 8273922 * @summary Unit test for java.nio.file.attribute.UserDefinedFileAttributeView + * (use -Dseed=X to set PRNG seed) * @library ../.. /test/lib * @key randomness * @build jdk.test.lib.Platform + * @build jdk.test.lib.RandomFactory + * @build jtreg.SkippedException * @run main Basic */ @@ -38,17 +41,20 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.LinkOption; import java.nio.file.Path; -import static java.nio.file.LinkOption.*; -import java.nio.file.attribute.*; +import java.nio.file.attribute.UserDefinedFileAttributeView; import java.util.Arrays; import java.util.Map; import java.util.Random; + import jdk.test.lib.Platform; +import jdk.test.lib.RandomFactory; + +import jtreg.SkippedException; public class Basic { // Must be indeterministic - private static final Random rand = new Random(); + private static final Random rand = RandomFactory.getRandom(); private static final String ATTR_NAME = "mime_type"; private static final String ATTR_VALUE = "text/plain"; @@ -281,10 +287,8 @@ public class Basic { // create temporary directory to run tests Path dir = TestUtil.createTemporaryDirectory(); try { - if (!Files.getFileStore(dir).supportsFileAttributeView("user")) { - System.out.println("UserDefinedFileAttributeView not supported - skip test"); - return; - } + if (!Files.getFileStore(dir).supportsFileAttributeView("user")) + throw new SkippedException("UserDefinedFileAttributeView not supported"); // test access to user defined attributes of regular file Path file = dir.resolve("foo.html"); @@ -310,7 +314,7 @@ public class Basic { Path link = dir.resolve("link"); Files.createSymbolicLink(link, target); try { - test(link, NOFOLLOW_LINKS); + test(link, LinkOption.NOFOLLOW_LINKS); } catch (IOException x) { // access to attributes of sym link may not be supported } finally { From 89a18c0108e10dc4ca4a4fa9e8718d49036f8871 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Wed, 28 Jan 2026 17:58:15 +0000 Subject: [PATCH 095/105] 8376432: Remove AppContext from sun/swing/DefaultLookup.java Reviewed-by: psadhukhan, azvegint, aivanov --- .../classes/sun/swing/DefaultLookup.java | 51 +++++-------------- 1 file changed, 12 insertions(+), 39 deletions(-) diff --git a/src/java.desktop/share/classes/sun/swing/DefaultLookup.java b/src/java.desktop/share/classes/sun/swing/DefaultLookup.java index d7a7f22eba3..a2ae0921507 100644 --- a/src/java.desktop/share/classes/sun/swing/DefaultLookup.java +++ b/src/java.desktop/share/classes/sun/swing/DefaultLookup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2026, 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 @@ -29,7 +29,6 @@ import java.awt.Insets; import javax.swing.*; import javax.swing.border.Border; import javax.swing.plaf.ComponentUI; -import sun.awt.AppContext; /** * DefaultLookup provides a way to customize the lookup done by the @@ -44,17 +43,9 @@ import sun.awt.AppContext; * @author Scott Violet */ public class DefaultLookup { + /** - * Key used to store DefaultLookup for AppContext. - */ - private static final Object DEFAULT_LOOKUP_KEY = new - StringBuffer("DefaultLookup"); - /** - * Thread that last asked for a default. - */ - private static Thread currentDefaultThread; - /** - * DefaultLookup for last thread. + * DefaultLookup currently set. */ private static DefaultLookup currentDefaultLookup; @@ -63,28 +54,24 @@ public class DefaultLookup { */ private static boolean isLookupSet; - /** - * Sets the DefaultLookup instance to use for the current - * AppContext. Null implies the UIManager should be - * used. + * Sets the DefaultLookup instance to use. + * Null implies the UIManager should be used. */ public static void setDefaultLookup(DefaultLookup lookup) { synchronized(DefaultLookup.class) { if (!isLookupSet && lookup == null) { - // Null was passed in, and no one has invoked setDefaultLookup + // Null was passed in, and no one has previously invoked setDefaultLookup // with a non-null value, we don't need to do anything. return; } else if (lookup == null) { - // null was passed in, but someone has invoked setDefaultLookup + // null was passed in, but someone has previously invoked setDefaultLookup // with a non-null value, use an instance of DefaultLookup // which will fallback to UIManager. lookup = new DefaultLookup(); } isLookupSet = true; - AppContext.getAppContext().put(DEFAULT_LOOKUP_KEY, lookup); - currentDefaultThread = Thread.currentThread(); currentDefaultLookup = lookup; } } @@ -98,27 +85,13 @@ public class DefaultLookup { // No one has set a valid DefaultLookup, use UIManager. return UIManager.get(key, c.getLocale()); } - Thread thisThread = Thread.currentThread(); DefaultLookup lookup; synchronized(DefaultLookup.class) { - // See if we've already cached the DefaultLookup for this thread, - // and use it if we have. - if (thisThread == currentDefaultThread) { - // It is cached, use it. - lookup = currentDefaultLookup; - } - else { - // Not cached, get the DefaultLookup to use from the AppContext - lookup = (DefaultLookup)AppContext.getAppContext().get( - DEFAULT_LOOKUP_KEY); - if (lookup == null) { - // Fallback to DefaultLookup, which will redirect to the - // UIManager. - lookup = new DefaultLookup(); - AppContext.getAppContext().put(DEFAULT_LOOKUP_KEY, lookup); - } - // Cache the values to make the next lookup easier. - currentDefaultThread = thisThread; + lookup = currentDefaultLookup; + if (lookup == null) { + // Fallback to DefaultLookup, which will redirect to the + // UIManager. + lookup = new DefaultLookup(); currentDefaultLookup = lookup; } } From 7efa3168b706c1d061c4ee65574427ef1f50fc7b Mon Sep 17 00:00:00 2001 From: Phil Race Date: Wed, 28 Jan 2026 18:01:10 +0000 Subject: [PATCH 096/105] 8376434: Remove AppContext from awt ImageFetcher implementation Reviewed-by: azvegint, aivanov --- .../classes/sun/awt/image/ImageFetcher.java | 61 ++++++------------- 1 file changed, 18 insertions(+), 43 deletions(-) diff --git a/src/java.desktop/share/classes/sun/awt/image/ImageFetcher.java b/src/java.desktop/share/classes/sun/awt/image/ImageFetcher.java index 74c7c4d2ce2..917378389a4 100644 --- a/src/java.desktop/share/classes/sun/awt/image/ImageFetcher.java +++ b/src/java.desktop/share/classes/sun/awt/image/ImageFetcher.java @@ -26,7 +26,6 @@ package sun.awt.image; import java.util.Vector; -import sun.awt.AppContext; /** * An ImageFetcher is a thread used to fetch ImageFetchable objects. @@ -34,10 +33,6 @@ import sun.awt.AppContext; * thread may also be used to animate it if necessary, via the * startingAnimation() / stoppingAnimation() methods. * - * There can be up to FetcherInfo.MAX_NUM_FETCHERS_PER_APPCONTEXT - * ImageFetcher threads for each AppContext. A per-AppContext queue - * of ImageFetchables is used to track objects to fetch. - * * @author Jim Graham * @author Fred Ecks */ @@ -153,7 +148,6 @@ class ImageFetcher extends Thread { info.numWaiting++; info.waitList.wait(end - now); } catch (InterruptedException e) { - // A normal occurrence as an AppContext is disposed return null; } finally { info.numWaiting--; @@ -280,28 +274,20 @@ class ImageFetcher extends Thread { // We need to instantiate a new ImageFetcher thread. // First, figure out which ThreadGroup we'll put the // new ImageFetcher into - final AppContext appContext = AppContext.getAppContext(); - ThreadGroup threadGroup = appContext.getThreadGroup(); - ThreadGroup fetcherThreadGroup; - if (threadGroup.getParent() != null) { - // threadGroup is not the root, so we proceed - fetcherThreadGroup = threadGroup; - } else { - // threadGroup is the root ("system") ThreadGroup. - // We instead want to use its child: the "main" - // ThreadGroup. Thus, we start with the current - // ThreadGroup, and go up the tree until - // threadGroup.getParent().getParent() == null. - threadGroup = Thread.currentThread().getThreadGroup(); - ThreadGroup parent = threadGroup.getParent(); - while ((parent != null) - && (parent.getParent() != null)) { - threadGroup = parent; - parent = threadGroup.getParent(); - } - fetcherThreadGroup = threadGroup; + // We don't want the root ("system") ThreadGroup. + // We instead want to use its child: the "main" + // ThreadGroup. Thus, we start with the current + // ThreadGroup, and go up the tree until + // threadGroup.getParent().getParent() == null. + ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); + ThreadGroup parent = threadGroup.getParent(); + while ((parent != null) + && (parent.getParent() != null)) { + threadGroup = parent; + parent = threadGroup.getParent(); } - final ThreadGroup fetcherGroup = fetcherThreadGroup; + final ThreadGroup fetcherGroup = threadGroup; + for (int i = 0; i < info.fetchers.length; i++) { if (info.fetchers[i] == null) { @@ -320,12 +306,13 @@ class ImageFetcher extends Thread { } /** - * The FetcherInfo class encapsulates the per-AppContext ImageFetcher + * The FetcherInfo class encapsulates the ImageFetcher * information. This includes the array of ImageFetchers, as well as * the queue of ImageFetchable objects. */ class FetcherInfo { - static final int MAX_NUM_FETCHERS_PER_APPCONTEXT = 4; + static final int MAX_NUM_FETCHERS = 4; + static final FetcherInfo FETCHER_INFO = new FetcherInfo(); Thread[] fetchers; int numFetchers; @@ -333,25 +320,13 @@ class FetcherInfo { Vector waitList; private FetcherInfo() { - fetchers = new Thread[MAX_NUM_FETCHERS_PER_APPCONTEXT]; + fetchers = new Thread[MAX_NUM_FETCHERS]; numFetchers = 0; numWaiting = 0; waitList = new Vector<>(); } - /* The key to put()/get() the FetcherInfo into/from the AppContext. */ - private static final Object FETCHER_INFO_KEY = - new StringBuffer("FetcherInfo"); - static FetcherInfo getFetcherInfo() { - AppContext appContext = AppContext.getAppContext(); - synchronized(appContext) { - FetcherInfo info = (FetcherInfo)appContext.get(FETCHER_INFO_KEY); - if (info == null) { - info = new FetcherInfo(); - appContext.put(FETCHER_INFO_KEY, info); - } - return info; - } + return FETCHER_INFO; } } From 0722ae926ff1327c47a922b1ca0b493a0d06526e Mon Sep 17 00:00:00 2001 From: Phil Race Date: Wed, 28 Jan 2026 19:53:41 +0000 Subject: [PATCH 097/105] 8376433: Remove AppContext from Swing Windows L&F implementation Reviewed-by: serb, aivanov --- .../plaf/windows/AnimationController.java | 19 ++++++------------- .../swing/plaf/windows/WindowsButtonUI.java | 15 +++------------ .../swing/plaf/windows/WindowsCheckBoxUI.java | 15 +++------------ .../swing/plaf/windows/WindowsLabelUI.java | 14 +++----------- .../plaf/windows/WindowsRadioButtonUI.java | 15 +++------------ .../plaf/windows/WindowsToggleButtonUI.java | 15 +++------------ 6 files changed, 21 insertions(+), 72 deletions(-) diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/AnimationController.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/AnimationController.java index 4fb843543e3..06574d17641 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/AnimationController.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/AnimationController.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2026, 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 @@ -39,8 +39,6 @@ import com.sun.java.swing.plaf.windows.TMSchema.Part; import com.sun.java.swing.plaf.windows.TMSchema.Prop; import com.sun.java.swing.plaf.windows.XPStyle.Skin; -import sun.awt.AppContext; - /** * A class to help mimic Vista theme animations. The only kind of * animation it handles for now is 'transition' animation (this seems @@ -68,8 +66,7 @@ final class AnimationController implements ActionListener, PropertyChangeListene Boolean.getBoolean("swing.disablevistaanimation"); - private static final Object ANIMATION_CONTROLLER_KEY = - new StringBuilder("ANIMATION_CONTROLLER_KEY"); + private static AnimationController animationController; private final Map> animationStateMap = new WeakHashMap>(); @@ -80,13 +77,10 @@ final class AnimationController implements ActionListener, PropertyChangeListene new javax.swing.Timer(1000/30, this); private static synchronized AnimationController getAnimationController() { - AppContext appContext = AppContext.getAppContext(); - Object obj = appContext.get(ANIMATION_CONTROLLER_KEY); - if (obj == null) { - obj = new AnimationController(); - appContext.put(ANIMATION_CONTROLLER_KEY, obj); + if (animationController == null) { + animationController = new AnimationController(); } - return (AnimationController) obj; + return animationController; } private AnimationController() { @@ -316,8 +310,7 @@ final class AnimationController implements ActionListener, PropertyChangeListene timer.stop(); UIManager.removePropertyChangeListener(this); synchronized (AnimationController.class) { - AppContext.getAppContext() - .put(ANIMATION_CONTROLLER_KEY, null); + animationController = null; } } diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsButtonUI.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsButtonUI.java index 0c86bd33e10..ee07276aa30 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsButtonUI.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsButtonUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -47,8 +47,6 @@ import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicButtonUI; import javax.swing.plaf.basic.BasicGraphicsUtils; -import sun.awt.AppContext; - import static com.sun.java.swing.plaf.windows.TMSchema.Part; import static com.sun.java.swing.plaf.windows.TMSchema.State; import static com.sun.java.swing.plaf.windows.XPStyle.Skin; @@ -69,20 +67,13 @@ public final class WindowsButtonUI extends BasicButtonUI private boolean defaults_initialized = false; - private static final Object WINDOWS_BUTTON_UI_KEY = new Object(); + private static final ComponentUI UI = new WindowsButtonUI(); // ******************************** // Create PLAF // ******************************** public static ComponentUI createUI(JComponent c) { - AppContext appContext = AppContext.getAppContext(); - WindowsButtonUI windowsButtonUI = - (WindowsButtonUI) appContext.get(WINDOWS_BUTTON_UI_KEY); - if (windowsButtonUI == null) { - windowsButtonUI = new WindowsButtonUI(); - appContext.put(WINDOWS_BUTTON_UI_KEY, windowsButtonUI); - } - return windowsButtonUI; + return UI; } diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsCheckBoxUI.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsCheckBoxUI.java index 3c869efc97b..7cb2490fd76 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsCheckBoxUI.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsCheckBoxUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -30,8 +30,6 @@ import javax.swing.JComponent; import javax.swing.UIManager; import javax.swing.plaf.ComponentUI; -import sun.awt.AppContext; - /** * Windows check box. * @@ -43,7 +41,7 @@ public final class WindowsCheckBoxUI extends WindowsRadioButtonUI // of BasicCheckBoxUI because we want to pick up all the // painting changes made in WindowsRadioButtonUI. - private static final Object WINDOWS_CHECK_BOX_UI_KEY = new Object(); + private static final ComponentUI UI = new WindowsCheckBoxUI(); private static final String propertyPrefix = "CheckBox" + "."; @@ -53,14 +51,7 @@ public final class WindowsCheckBoxUI extends WindowsRadioButtonUI // Create PLAF // ******************************** public static ComponentUI createUI(JComponent c) { - AppContext appContext = AppContext.getAppContext(); - WindowsCheckBoxUI windowsCheckBoxUI = - (WindowsCheckBoxUI) appContext.get(WINDOWS_CHECK_BOX_UI_KEY); - if (windowsCheckBoxUI == null) { - windowsCheckBoxUI = new WindowsCheckBoxUI(); - appContext.put(WINDOWS_CHECK_BOX_UI_KEY, windowsCheckBoxUI); - } - return windowsCheckBoxUI; + return UI; } diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsLabelUI.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsLabelUI.java index 403468af0af..4283f743b97 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsLabelUI.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsLabelUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -34,7 +34,6 @@ import javax.swing.UIManager; import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicLabelUI; -import sun.awt.AppContext; import sun.swing.MnemonicHandler; import sun.swing.SwingUtilities2; @@ -43,20 +42,13 @@ import sun.swing.SwingUtilities2; */ public final class WindowsLabelUI extends BasicLabelUI { - private static final Object WINDOWS_LABEL_UI_KEY = new Object(); + private static final ComponentUI UI = new WindowsLabelUI(); // ******************************** // Create PLAF // ******************************** public static ComponentUI createUI(JComponent c) { - AppContext appContext = AppContext.getAppContext(); - WindowsLabelUI windowsLabelUI = - (WindowsLabelUI) appContext.get(WINDOWS_LABEL_UI_KEY); - if (windowsLabelUI == null) { - windowsLabelUI = new WindowsLabelUI(); - appContext.put(WINDOWS_LABEL_UI_KEY, windowsLabelUI); - } - return windowsLabelUI; + return UI; } @Override diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsRadioButtonUI.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsRadioButtonUI.java index 2a784a470a4..c62a9ec8586 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsRadioButtonUI.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsRadioButtonUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -38,14 +38,12 @@ import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicGraphicsUtils; import javax.swing.plaf.basic.BasicRadioButtonUI; -import sun.awt.AppContext; - /** * Windows rendition of the component. */ public class WindowsRadioButtonUI extends BasicRadioButtonUI { - private static final Object WINDOWS_RADIO_BUTTON_UI_KEY = new Object(); + private static final ComponentUI UI = new WindowsRadioButtonUI(); protected int dashedRectGapX; protected int dashedRectGapY; @@ -60,14 +58,7 @@ public class WindowsRadioButtonUI extends BasicRadioButtonUI // Create PLAF // ******************************** public static ComponentUI createUI(JComponent c) { - AppContext appContext = AppContext.getAppContext(); - WindowsRadioButtonUI windowsRadioButtonUI = - (WindowsRadioButtonUI) appContext.get(WINDOWS_RADIO_BUTTON_UI_KEY); - if (windowsRadioButtonUI == null) { - windowsRadioButtonUI = new WindowsRadioButtonUI(); - appContext.put(WINDOWS_RADIO_BUTTON_UI_KEY, windowsRadioButtonUI); - } - return windowsRadioButtonUI; + return UI; } // ******************************** diff --git a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsToggleButtonUI.java b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsToggleButtonUI.java index 5e94ebdb2cc..67eb5c1d6a0 100644 --- a/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsToggleButtonUI.java +++ b/src/java.desktop/windows/classes/com/sun/java/swing/plaf/windows/WindowsToggleButtonUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -38,8 +38,6 @@ import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicGraphicsUtils; import javax.swing.plaf.basic.BasicToggleButtonUI; -import sun.awt.AppContext; - /** * A Windows toggle button. * @@ -54,19 +52,12 @@ public final class WindowsToggleButtonUI extends BasicToggleButtonUI protected Color focusColor; - private static final Object WINDOWS_TOGGLE_BUTTON_UI_KEY = new Object(); + private static final ComponentUI UI = new WindowsToggleButtonUI(); private boolean defaults_initialized = false; public static ComponentUI createUI(JComponent b) { - AppContext appContext = AppContext.getAppContext(); - WindowsToggleButtonUI windowsToggleButtonUI = - (WindowsToggleButtonUI) appContext.get(WINDOWS_TOGGLE_BUTTON_UI_KEY); - if (windowsToggleButtonUI == null) { - windowsToggleButtonUI = new WindowsToggleButtonUI(); - appContext.put(WINDOWS_TOGGLE_BUTTON_UI_KEY, windowsToggleButtonUI); - } - return windowsToggleButtonUI; + return UI; } From 09ed8e66dc7a788763a2c7c24f54e93ec8eafedb Mon Sep 17 00:00:00 2001 From: Xiaolong Peng Date: Wed, 28 Jan 2026 21:28:16 +0000 Subject: [PATCH 098/105] 8376531: Genshen: Convert ShenandoahOldGeneration to use Atomic Reviewed-by: wkemper, shade --- .../gc/shenandoah/shenandoahOldGeneration.cpp | 22 +++++++++---------- .../gc/shenandoah/shenandoahOldGeneration.hpp | 10 ++++----- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp index aed768b9db1..d5e34d02b13 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.cpp @@ -63,7 +63,7 @@ private: uint _nworkers; ShenandoahHeapRegion** _coalesce_and_fill_region_array; uint _coalesce_and_fill_region_count; - volatile bool _is_preempted; + Atomic _is_preempted; public: ShenandoahConcurrentCoalesceAndFillTask(uint nworkers, @@ -88,7 +88,7 @@ public: if (!r->oop_coalesce_and_fill(true)) { // Coalesce and fill has been preempted - AtomicAccess::store(&_is_preempted, true); + _is_preempted.store_relaxed(true); return; } } @@ -96,7 +96,7 @@ public: // Value returned from is_completed() is only valid after all worker thread have terminated. bool is_completed() { - return !AtomicAccess::load(&_is_preempted); + return !_is_preempted.load_relaxed(); } }; @@ -147,23 +147,23 @@ void ShenandoahOldGeneration::augment_promoted_reserve(size_t increment) { void ShenandoahOldGeneration::reset_promoted_expended() { shenandoah_assert_heaplocked_or_safepoint(); - AtomicAccess::store(&_promoted_expended, static_cast(0)); - AtomicAccess::store(&_promotion_failure_count, static_cast(0)); - AtomicAccess::store(&_promotion_failure_words, static_cast(0)); + _promoted_expended.store_relaxed(0); + _promotion_failure_count.store_relaxed(0); + _promotion_failure_words.store_relaxed(0); } size_t ShenandoahOldGeneration::expend_promoted(size_t increment) { shenandoah_assert_heaplocked_or_safepoint(); assert(get_promoted_expended() + increment <= get_promoted_reserve(), "Do not expend more promotion than budgeted"); - return AtomicAccess::add(&_promoted_expended, increment); + return _promoted_expended.add_then_fetch(increment); } size_t ShenandoahOldGeneration::unexpend_promoted(size_t decrement) { - return AtomicAccess::sub(&_promoted_expended, decrement); + return _promoted_expended.sub_then_fetch(decrement); } size_t ShenandoahOldGeneration::get_promoted_expended() const { - return AtomicAccess::load(&_promoted_expended); + return _promoted_expended.load_relaxed(); } bool ShenandoahOldGeneration::can_allocate(const ShenandoahAllocRequest &req) const { @@ -582,8 +582,8 @@ void ShenandoahOldGeneration::handle_failed_evacuation() { } void ShenandoahOldGeneration::handle_failed_promotion(Thread* thread, size_t size) { - AtomicAccess::inc(&_promotion_failure_count); - AtomicAccess::add(&_promotion_failure_words, size); + _promotion_failure_count.add_then_fetch(1UL); + _promotion_failure_words.and_then_fetch(size); LogTarget(Debug, gc, plab) lt; LogStream ls(lt); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp index 633d2c9f617..5ebad461f3c 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOldGeneration.hpp @@ -64,7 +64,7 @@ private: // is therefore always accessed through atomic operations. This is increased when a // PLAB is allocated for promotions. The value is decreased by the amount of memory // remaining in a PLAB when it is retired. - size_t _promoted_expended; + Atomic _promoted_expended; // Represents the quantity of live bytes we expect to promote during the next GC cycle, either by // evacuation or by promote-in-place. This value is used by the young heuristic to trigger mixed collections. @@ -78,8 +78,8 @@ private: // Keep track of the number and size of promotions that failed. Perhaps we should use this to increase // the size of the old generation for the next collection cycle. - size_t _promotion_failure_count; - size_t _promotion_failure_words; + Atomic _promotion_failure_count; + Atomic _promotion_failure_words; // During construction of the collection set, we keep track of regions that are eligible // for promotion in place. These fields track the count of those humongous and regular regions. @@ -126,8 +126,8 @@ public: size_t get_promoted_expended() const; // Return the count and size (in words) of failed promotions since the last reset - size_t get_promotion_failed_count() const { return AtomicAccess::load(&_promotion_failure_count); } - size_t get_promotion_failed_words() const { return AtomicAccess::load(&_promotion_failure_words); } + size_t get_promotion_failed_count() const { return _promotion_failure_count.load_relaxed(); } + size_t get_promotion_failed_words() const { return _promotion_failure_words.load_relaxed(); } // Test if there is enough memory reserved for this promotion bool can_promote(size_t requested_bytes) const { From 2529e2fe8dfe9685033bb0ae558266b8bc3cf95c Mon Sep 17 00:00:00 2001 From: Prasanta Sadhukhan Date: Thu, 29 Jan 2026 02:30:41 +0000 Subject: [PATCH 099/105] 8376169: JPopupMenu.setInvoker(null) causes NPE Reviewed-by: aivanov, azvegint, prr, kizune --- .../share/classes/javax/swing/JPopupMenu.java | 6 ++++-- .../jdk/javax/swing/JPopupMenu/TestPopupInvoker.java | 12 ++++++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/java.desktop/share/classes/javax/swing/JPopupMenu.java b/src/java.desktop/share/classes/javax/swing/JPopupMenu.java index 38bde1a97fa..1b04e8c6169 100644 --- a/src/java.desktop/share/classes/javax/swing/JPopupMenu.java +++ b/src/java.desktop/share/classes/javax/swing/JPopupMenu.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -960,7 +960,9 @@ public class JPopupMenu extends JComponent implements Accessible,MenuElement { if (oldInvoker != null) { oldInvoker.removePropertyChangeListener("ancestor", propListener); } - invoker.addPropertyChangeListener("ancestor", propListener); + if (invoker != null) { + invoker.addPropertyChangeListener("ancestor", propListener); + } ui.installUI(this); } invalidate(); diff --git a/test/jdk/javax/swing/JPopupMenu/TestPopupInvoker.java b/test/jdk/javax/swing/JPopupMenu/TestPopupInvoker.java index c8ddfe67999..a3dc658df0e 100644 --- a/test/jdk/javax/swing/JPopupMenu/TestPopupInvoker.java +++ b/test/jdk/javax/swing/JPopupMenu/TestPopupInvoker.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 2026, 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 @@ -23,13 +23,14 @@ /* * @test - * @bug 4938801 + * @bug 4938801 8376169 * @key headful * @summary Verifies popup is removed when the component is removed * @run main TestPopupInvoker */ import java.awt.BorderLayout; +import java.awt.Component; import java.awt.Container; import java.awt.Robot; import java.util.concurrent.CountDownLatch; @@ -48,6 +49,7 @@ public class TestPopupInvoker { static JFrame frame; static JLabel label; static Container pane; + static volatile Component invoker; private static final CountDownLatch popupShown = new CountDownLatch(1); private static final CountDownLatch popupHidden = new CountDownLatch(1); @@ -73,6 +75,7 @@ public class TestPopupInvoker { @Override public void popupMenuWillBecomeInvisible(PopupMenuEvent e) { popupHidden.countDown(); + popupMenu.setInvoker(null); } @Override @@ -106,6 +109,11 @@ public class TestPopupInvoker { if (!popupHidden.await(1, SECONDS)) { throw new RuntimeException("Popup is visible after component is removed"); } + + SwingUtilities.invokeAndWait(() -> invoker = popupMenu.getInvoker()); + if (invoker != null) { + throw new RuntimeException("Invoker is not null"); + } } finally { SwingUtilities.invokeAndWait(() -> { if (frame != null) { From 62c7e9aefd4320d9d0cd8fa10610f59abb4de670 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 29 Jan 2026 04:49:56 +0000 Subject: [PATCH 100/105] 8376423: Test javax/swing/plaf/metal/MetalUtils/bug6190373.java failed: ClassCastException: class java.lang.Character cannot be cast to class javax.swing.Painter Reviewed-by: aivanov, tr --- .../share/classes/javax/swing/UIManager.java | 28 ++--- .../swing/plaf/metal/DefaultMetalTheme.java | 7 +- .../classes/sun/swing/SwingAccessor.java | 29 ++++- .../classes/sun/swing/SwingUtilities2.java | 8 +- .../javax/swing/UIManager/Test6657026.java | 60 ---------- .../plaf/metal/MetalUtils/bug6190373.java | 112 ------------------ 6 files changed, 45 insertions(+), 199 deletions(-) delete mode 100644 test/jdk/javax/swing/UIManager/Test6657026.java delete mode 100644 test/jdk/javax/swing/plaf/metal/MetalUtils/bug6190373.java diff --git a/src/java.desktop/share/classes/javax/swing/UIManager.java b/src/java.desktop/share/classes/javax/swing/UIManager.java index 7a2ae226f33..69063c562e6 100644 --- a/src/java.desktop/share/classes/javax/swing/UIManager.java +++ b/src/java.desktop/share/classes/javax/swing/UIManager.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -59,6 +59,7 @@ import java.util.Objects; import sun.awt.AppContext; import sun.awt.AWTAccessor; +import sun.swing.SwingAccessor; /** * {@code UIManager} manages the current look and feel, the set of @@ -233,8 +234,9 @@ public class UIManager implements Serializable */ public UIManager() {} + private static final LAFState LAF_STATE = new LAFState(); /** - * Return the LAFState object, lazily create one if necessary. + * Return the LAFState object. * All access to the LAFState fields is done via this method, * for example: * 

    @@ -242,22 +244,18 @@ public class UIManager implements Serializable
      *
    */ private static LAFState getLAFState() { - LAFState rv = (LAFState)SwingUtilities.appContextGet( - SwingUtilities2.LAF_STATE_KEY); - if (rv == null) { - synchronized (classLock) { - rv = (LAFState)SwingUtilities.appContextGet( - SwingUtilities2.LAF_STATE_KEY); - if (rv == null) { - SwingUtilities.appContextPut( - SwingUtilities2.LAF_STATE_KEY, - (rv = new LAFState())); - } - } + synchronized (classLock) { + return LAF_STATE; } - return rv; } + static { + SwingAccessor.setLAFStateAccessor(UIManager::isLafStateInitialized); + } + + private static boolean isLafStateInitialized() { + return LAF_STATE.initialized; + } /* Keys used in the swing.properties properties file. * See loadUserProperties(), initialize(). diff --git a/src/java.desktop/share/classes/javax/swing/plaf/metal/DefaultMetalTheme.java b/src/java.desktop/share/classes/javax/swing/plaf/metal/DefaultMetalTheme.java index 8ee862fb0b3..d64267676c3 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/metal/DefaultMetalTheme.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/metal/DefaultMetalTheme.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2026, 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 @@ -29,7 +29,7 @@ import javax.swing.plaf.*; import javax.swing.*; import java.awt.*; -import sun.awt.AppContext; +import sun.swing.SwingAccessor; import sun.swing.SwingUtilities2; /** @@ -153,8 +153,7 @@ public class DefaultMetalTheme extends MetalTheme { static int getDefaultFontStyle(int key) { if (key != WINDOW_TITLE_FONT) { Object boldMetal = null; - if (AppContext.getAppContext().get( - SwingUtilities2.LAF_STATE_KEY) != null) { + if (SwingAccessor.getLAFStateAccessor().lafStateIsInitialized()) { // Only access the boldMetal key if a look and feel has // been loaded, otherwise we'll trigger loading the look // and feel. diff --git a/src/java.desktop/share/classes/sun/swing/SwingAccessor.java b/src/java.desktop/share/classes/sun/swing/SwingAccessor.java index 5c561de4a42..563cc038ae9 100644 --- a/src/java.desktop/share/classes/sun/swing/SwingAccessor.java +++ b/src/java.desktop/share/classes/sun/swing/SwingAccessor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2026, 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 @@ -133,6 +133,33 @@ public final class SwingAccessor { KeyStroke create(); } + /** + * An accessor for the LAFState class state. + */ + public interface LAFStateAccessor { + boolean lafStateIsInitialized(); + } + + private static LAFStateAccessor lafStateAccessor; + /** + * Set an accessor object for the LAFState class. + */ + public static void setLAFStateAccessor(LAFStateAccessor accessor) { + lafStateAccessor = accessor; + } + + /** + * Retrieve the accessor object for the LAFState class. + */ + public static LAFStateAccessor getLAFStateAccessor() { + var access = lafStateAccessor; + if (access == null) { + ensureClassInitialized(UIManager.class); + access = lafStateAccessor; + } + return access; + } + /** * The javax.swing.JComponent class accessor object. */ diff --git a/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java b/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java index 20a07c608a0..faf31e0b426 100644 --- a/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java +++ b/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2026, 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 @@ -120,12 +120,6 @@ import static java.awt.geom.AffineTransform.TYPE_TRANSLATION; * */ public class SwingUtilities2 { - /** - * The {@code AppContext} key for our one {@code LAFState} - * instance. - */ - public static final Object LAF_STATE_KEY = - new StringBuffer("LookAndFeel State"); public static final Object MENU_SELECTION_MANAGER_LISTENER_KEY = new StringBuffer("MenuSelectionManager listener key"); diff --git a/test/jdk/javax/swing/UIManager/Test6657026.java b/test/jdk/javax/swing/UIManager/Test6657026.java deleted file mode 100644 index 5ce1ea73de4..00000000000 --- a/test/jdk/javax/swing/UIManager/Test6657026.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2009, 2015, 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 6657026 - * @summary Tests shared UIManager in different application contexts - * @author Sergey Malenkov - * @modules java.desktop/sun.awt - */ - -import sun.awt.SunToolkit; - -import javax.swing.UIManager; -import javax.swing.UIManager.LookAndFeelInfo; - -public class Test6657026 implements Runnable { - - public static void main(String[] args) throws Exception { - if (UIManager.getInstalledLookAndFeels().length == 0) { - throw new Error("unexpected amount of look&feels"); - } - UIManager.setInstalledLookAndFeels(new LookAndFeelInfo[0]); - if (UIManager.getInstalledLookAndFeels().length != 0) { - throw new Error("unexpected amount of look&feels"); - } - - ThreadGroup group = new ThreadGroup("$$$"); - Thread thread = new Thread(group, new Test6657026()); - thread.start(); - thread.join(); - } - - public void run() { - SunToolkit.createNewAppContext(); - if (UIManager.getInstalledLookAndFeels().length == 0) { - throw new Error("shared look&feels"); - } - } -} diff --git a/test/jdk/javax/swing/plaf/metal/MetalUtils/bug6190373.java b/test/jdk/javax/swing/plaf/metal/MetalUtils/bug6190373.java deleted file mode 100644 index 07211c7a569..00000000000 --- a/test/jdk/javax/swing/plaf/metal/MetalUtils/bug6190373.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright (c) 2005, 2018, 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. - */ - -import java.awt.Graphics; -import java.awt.image.BufferedImage; -import java.util.concurrent.CyclicBarrier; - -import javax.swing.JButton; -import javax.swing.SwingUtilities; -import javax.swing.UIManager; -import javax.swing.UnsupportedLookAndFeelException; - -import sun.awt.AppContext; -import sun.awt.SunToolkit; - -import static javax.swing.UIManager.getInstalledLookAndFeels; - -/** - * @test - * @bug 6190373 - * @summary Tests 6190373 - * @author Scott Violet - * @modules java.desktop/sun.awt - */ -public final class bug6190373 { - - private static AppContext app1; - private static AppContext app2; - private static final int LOOP_COUNT = 10000; - private static final CyclicBarrier barrier = new CyclicBarrier(2); - - public static void main(final String[] args) throws Exception { - final Thread t1 = new Thread(new ThreadGroup("firstGroup"), () -> { - app1 = SunToolkit.createNewAppContext(); - test(true); - }); - final Thread t2 = new Thread(new ThreadGroup("secondGroup"), () -> { - app2 = SunToolkit.createNewAppContext(); - test(false); - }); - - t1.start(); - t2.start(); - t1.join(); - t2.join(); - app1.dispose(); - app2.dispose(); - } - - private static void test(final boolean lock) { - for (final UIManager.LookAndFeelInfo laf : getInstalledLookAndFeels()) { - try { - SwingUtilities.invokeAndWait(() -> setLookAndFeel(laf)); - barrier.await(); - SwingUtilities.invokeAndWait(() -> slam(lock)); - barrier.await(); - } catch (final Exception e) { - throw new RuntimeException(e); - } - } - } - - private static void slam(final boolean lock) { - JButton button = new JButton("HI"); - button.setSize(100, 100); - BufferedImage image = new BufferedImage(100, 100, - BufferedImage.TYPE_INT_RGB); - for (int i = 0; i < LOOP_COUNT; i++) { - Graphics g = image.getGraphics(); - if (lock) { - synchronized (button.getTreeLock()) { - button.paint(g); - } - } else { - button.paint(g); - } - g.dispose(); - } - } - - private static void setLookAndFeel(final UIManager.LookAndFeelInfo laf) { - try { - UIManager.setLookAndFeel(laf.getClassName()); - System.out.println("LookAndFeel: " + laf.getClassName()); - } catch (final UnsupportedLookAndFeelException ignored){ - System.out.println("Unsupported LookAndFeel: " + laf.getClassName()); - } catch (ClassNotFoundException | InstantiationException | - IllegalAccessException e) { - throw new RuntimeException(e); - } - } -} From 19c6fdf11b01308e9f99ce5666bfffcfbc453de3 Mon Sep 17 00:00:00 2001 From: Jaikiran Pai Date: Thu, 29 Jan 2026 06:34:02 +0000 Subject: [PATCH 101/105] 8376290: SocketChannel.finishConnect() contains confusing "getsockopt" in exception message for a failed connect() on Windows Reviewed-by: alanb --- .../unix/native/libnet/net_util_md.c | 13 +- .../windows/native/libnet/net_util_md.c | 30 ++-- src/java.base/windows/native/libnio/ch/Net.c | 4 +- .../Selector/ConnectionRefusedMessage.java | 128 ++++++++++++++++++ 4 files changed, 153 insertions(+), 22 deletions(-) create mode 100644 test/jdk/java/nio/channels/Selector/ConnectionRefusedMessage.java diff --git a/src/java.base/unix/native/libnet/net_util_md.c b/src/java.base/unix/native/libnet/net_util_md.c index 1496be5f5c6..48cc1a7bb02 100644 --- a/src/java.base/unix/native/libnet/net_util_md.c +++ b/src/java.base/unix/native/libnet/net_util_md.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -68,13 +68,14 @@ NET_ThrowByNameWithLastError(JNIEnv *env, const char *name, void NET_ThrowNew(JNIEnv *env, int errorNumber, char *msg) { char fullMsg[512]; - if (!msg) { - msg = "no further information"; - } switch(errorNumber) { case EBADF: - jio_snprintf(fullMsg, sizeof(fullMsg), "socket closed: %s", msg); - JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg); + if (msg == NULL) { + JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed"); + } else { + jio_snprintf(fullMsg, sizeof(fullMsg), "socket closed: %s", msg); + JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg); + } break; default: errno = errorNumber; diff --git a/src/java.base/windows/native/libnet/net_util_md.c b/src/java.base/windows/native/libnet/net_util_md.c index bac3d1438ab..5abdd8d4c2e 100644 --- a/src/java.base/windows/native/libnet/net_util_md.c +++ b/src/java.base/windows/native/libnet/net_util_md.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2026, 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 @@ -139,13 +139,6 @@ NET_ThrowNew(JNIEnv *env, int errorNum, char *msg) return; } - /* - * Default message text if not provided - */ - if (!msg) { - msg = "no further information"; - } - /* * Check table for known winsock errors */ @@ -163,13 +156,22 @@ NET_ThrowNew(JNIEnv *env, int errorNum, char *msg) */ if (i < table_size) { excP = (char *)winsock_errors[i].exc; - jio_snprintf(fullMsg, sizeof(fullMsg), "%s: %s", - (char *)winsock_errors[i].errString, msg); + if (msg == NULL) { + jio_snprintf(fullMsg, sizeof(fullMsg), "%s", + (char *)winsock_errors[i].errString); + } else { + jio_snprintf(fullMsg, sizeof(fullMsg), "%s: %s", + (char *)winsock_errors[i].errString, msg); + } } else { - jio_snprintf(fullMsg, sizeof(fullMsg), - "Unrecognized Windows Sockets error: %d: %s", - errorNum, msg); - + if (msg == NULL) { + jio_snprintf(fullMsg, sizeof(fullMsg), + "Unrecognized Windows Sockets error: %d", errorNum); + } else { + jio_snprintf(fullMsg, sizeof(fullMsg), + "Unrecognized Windows Sockets error: %d: %s", + errorNum, msg); + } } /* diff --git a/src/java.base/windows/native/libnio/ch/Net.c b/src/java.base/windows/native/libnio/ch/Net.c index 814f502c48a..adfd67b5017 100644 --- a/src/java.base/windows/native/libnio/ch/Net.c +++ b/src/java.base/windows/native/libnio/ch/Net.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2026, 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 @@ -733,7 +733,7 @@ Java_sun_nio_ch_Net_pollConnect(JNIEnv* env, jclass this, jobject fdo, jlong tim NET_ThrowNew(env, lastError, "getsockopt"); } } else if (optError != NO_ERROR) { - NET_ThrowNew(env, optError, "getsockopt"); + NET_ThrowNew(env, optError, NULL); } return JNI_FALSE; } diff --git a/test/jdk/java/nio/channels/Selector/ConnectionRefusedMessage.java b/test/jdk/java/nio/channels/Selector/ConnectionRefusedMessage.java new file mode 100644 index 00000000000..5e7b6395a66 --- /dev/null +++ b/test/jdk/java/nio/channels/Selector/ConnectionRefusedMessage.java @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2026, 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. + */ + +import java.io.IOException; +import java.net.ConnectException; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.SocketChannel; +import java.time.Duration; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.api.Assumptions.assumeFalse; +import static org.junit.jupiter.api.Assumptions.assumeTrue; + +/* + * @test + * @bug 8376290 + * @summary Verify that when a SocketChannel is registered with a Selector + * with an interest in CONNECT operation, then SocketChannel.finishConnect() + * throws the correct exception message, if the connect() fails + * @run junit ${test.main.class} + */ +class ConnectionRefusedMessage { + + /* + * On a non-blocking SocketChannel, registered with a Selector, this test method + * attempts a SocketChannel.connect() against an address that is expected to return + * Connection refused. The test then calls SocketChannel.finishConnect() when the + * Selector makes available the ready key for this connect operation and expects + * that finishConnect() throws a ConnectException with the expected exception message. + */ + @Test + void testFinishConnect() throws Exception { + // find a suitable address against which the connect() attempt + // will result in a Connection refused exception + final InetSocketAddress destAddr = findSuitableRefusedAddress(); + // skip the test if we couldn't find a port which would raise a connection refused error + assumeTrue(destAddr != null, + "couldn't find a suitable port which will generate a connection refused error"); + try (Selector selector = Selector.open(); + SocketChannel sc = SocketChannel.open()) { + + // non-blocking + sc.configureBlocking(false); + sc.register(selector, SelectionKey.OP_CONNECT); + + System.err.println("establishing connection to " + destAddr); + boolean connected = sc.connect(destAddr); + // this test checks the exception message of a ConnectException, so it's + // OK to skip the test if something unexpectedly accepted the connection + assumeFalse(connected, "unexpectedly connected to " + destAddr); + // wait for ready ops + int numReady = selector.select(Duration.ofMinutes(10).toMillis()); + System.err.println("Num ready keys = " + numReady); + for (SelectionKey readyKey : selector.selectedKeys()) { + System.err.println("ready key: " + readyKey); + assertTrue(readyKey.isConnectable(), "unexpected key, readyOps = " + + readyKey.readyOps()); + readyKey.cancel(); + try { + boolean success = sc.finishConnect(); + // this test checks the exception message of a ConnectException, so it's + // OK to skip the test if something unexpectedly accepted the connection + assumeFalse(success, "unexpectedly connected to " + destAddr); + // this test doesn't expect finishConnect() to return normally + // with a return value of false + fail("ConnectException was not thrown"); + } catch (ConnectException ce) { + System.err.println("got (expected) ConnectException - " + ce); + // verify exception message + if (!"Connection refused".equals(ce.getMessage())) { + // propagate the original exception + fail("unexpected exception message: " + ce.getMessage(), ce); + } + } + } + } + } + + // Try to find a suitable port to provoke a "Connection Refused" error. + private static InetSocketAddress findSuitableRefusedAddress() throws IOException { + final InetAddress loopbackAddr = InetAddress.getLoopbackAddress(); + // Ports 47, 51, 61 are in the IANA reserved port list, and + // are currently unassigned to any specific service. + // We use them here on the assumption that there won't be + // any service listening on them. + InetSocketAddress destAddr = new InetSocketAddress(loopbackAddr, 47); + try (SocketChannel sc1 = SocketChannel.open(destAddr)) { + // we managed to connect (unexpectedly), let's try the next reserved port + destAddr = new InetSocketAddress(loopbackAddr, 51); + try (SocketChannel sc2 = SocketChannel.open(destAddr)) { + } + // we managed to connect (unexpectedly again), let's try the next reserved port + // as a last attempt + destAddr = new InetSocketAddress(loopbackAddr, 61); + try (SocketChannel sc3 = SocketChannel.open(destAddr)) { + } + return null; + } catch (ConnectException x) { + } + // the address which will generate a connection refused, when a connection is attempted + return destAddr; + } +} From 06d1345f2913830c273b9546c997e877f7958113 Mon Sep 17 00:00:00 2001 From: Emanuel Peter Date: Thu, 29 Jan 2026 08:39:10 +0000 Subject: [PATCH 102/105] 8373026: C2 SuperWord and Vector API: vector algorithms test and benchmark Co-authored-by: Otmar Ertl Reviewed-by: vlivanov, jbhateja, psandoz, xgong --- .../vectorization/TestVectorAlgorithms.java | 556 +++++++++++++ .../vectorization/VectorAlgorithmsImpl.java | 774 +++++++++++++++++ .../bench/vm/compiler/VectorAlgorithms.java | 274 +++++++ .../vm/compiler/VectorAlgorithmsImpl.java | 775 ++++++++++++++++++ 4 files changed, 2379 insertions(+) create mode 100644 test/hotspot/jtreg/compiler/vectorization/TestVectorAlgorithms.java create mode 100644 test/hotspot/jtreg/compiler/vectorization/VectorAlgorithmsImpl.java create mode 100644 test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithms.java create mode 100644 test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithmsImpl.java diff --git a/test/hotspot/jtreg/compiler/vectorization/TestVectorAlgorithms.java b/test/hotspot/jtreg/compiler/vectorization/TestVectorAlgorithms.java new file mode 100644 index 00000000000..e02563c2fc2 --- /dev/null +++ b/test/hotspot/jtreg/compiler/vectorization/TestVectorAlgorithms.java @@ -0,0 +1,556 @@ +/* + * Copyright (c) 2026, 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 id=vanilla + * @bug 8373026 + * @summary Test auto vectorization and Vector API with some vector + * algorithms. Related benchmark: VectorAlgorithms.java + * @library /test/lib / + * @modules jdk.incubator.vector + * @run driver ${test.main.class} + */ + +/* + * @test id=noSuperWord + * @bug 8373026 + * @library /test/lib / + * @modules jdk.incubator.vector + * @run driver ${test.main.class} -XX:-UseSuperWord + */ + +/* + * @test id=noOptimizeFill + * @bug 8373026 + * @library /test/lib / + * @modules jdk.incubator.vector + * @run driver ${test.main.class} -XX:-OptimizeFill + */ + +package compiler.vectorization; + +import java.util.Map; +import java.util.HashMap; +import jdk.test.lib.Utils; +import java.util.Random; +import java.lang.foreign.*; + +import compiler.lib.ir_framework.*; +import compiler.lib.generators.*; +import static compiler.lib.generators.Generators.G; +import compiler.lib.verify.*; + +/** + * The goal of this benchmark is to show the power of auto vectorization + * and the Vector API. + * + * Please only modify this benchark in synchronization with the JMH benchmark: + * micro/org/openjdk/bench/vm/compiler/VectorAlgorithms.java + */ +public class TestVectorAlgorithms { + private static final Random RANDOM = Utils.getRandomInstance(); + private static final RestrictableGenerator INT_GEN = Generators.G.ints(); + + interface TestFunction { + Object run(int i); + } + + Map> testGroups = new HashMap>(); + + VectorAlgorithmsImpl.Data d; + + public static void main(String[] args) { + TestFramework framework = new TestFramework(); + framework.addFlags("--add-modules=jdk.incubator.vector", + "-XX:CompileCommand=inline,*VectorAlgorithmsImpl*::*"); + framework.addFlags(args); + framework.start(); + } + + public TestVectorAlgorithms () { + testGroups.put("fillI", new HashMap()); + testGroups.get("fillI").put("fillI_loop", i -> { return fillI_loop(d.rI1); }); + testGroups.get("fillI").put("fillI_VectorAPI", i -> { return fillI_VectorAPI(d.rI2); }); + testGroups.get("fillI").put("fillI_Arrays", i -> { return fillI_Arrays(d.rI3); }); + + testGroups.put("iotaI", new HashMap()); + testGroups.get("iotaI").put("iotaI_loop", i -> { return iotaI_loop(d.rI1); }); + testGroups.get("iotaI").put("iotaI_VectorAPI", i -> { return iotaI_VectorAPI(d.rI2); }); + + testGroups.put("copyI", new HashMap()); + testGroups.get("copyI").put("copyI_loop", i -> { return copyI_loop(d.aI, d.rI1); }); + testGroups.get("copyI").put("copyI_VectorAPI", i -> { return copyI_VectorAPI(d.aI, d.rI2); }); + testGroups.get("copyI").put("copyI_System_arraycopy", i -> { return copyI_System_arraycopy(d.aI, d.rI3); }); + + testGroups.put("mapI", new HashMap()); + testGroups.get("mapI").put("mapI_loop", i -> { return mapI_loop(d.aI, d.rI1); }); + testGroups.get("mapI").put("mapI_VectorAPI", i -> { return mapI_VectorAPI(d.aI, d.rI2); }); + + testGroups.put("reduceAddI", new HashMap()); + testGroups.get("reduceAddI").put("reduceAddI_loop", i -> { return reduceAddI_loop(d.aI); }); + testGroups.get("reduceAddI").put("reduceAddI_reassociate", i -> { return reduceAddI_reassociate(d.aI); }); + testGroups.get("reduceAddI").put("reduceAddI_VectorAPI_naive", i -> { return reduceAddI_VectorAPI_naive(d.aI); }); + testGroups.get("reduceAddI").put("reduceAddI_VectorAPI_reduction_after_loop", i -> { return reduceAddI_VectorAPI_reduction_after_loop(d.aI); }); + + testGroups.put("dotProductF", new HashMap()); + testGroups.get("dotProductF").put("dotProductF_loop", i -> { return dotProductF_loop(d.aF, d.bF); }); + testGroups.get("dotProductF").put("dotProductF_VectorAPI_naive", i -> { return dotProductF_VectorAPI_naive(d.aF, d.bF); }); + testGroups.get("dotProductF").put("dotProductF_VectorAPI_reduction_after_loop", i -> { return dotProductF_VectorAPI_reduction_after_loop(d.aF, d.bF); }); + + testGroups.put("hashCodeB", new HashMap()); + testGroups.get("hashCodeB").put("hashCodeB_loop", i -> { return hashCodeB_loop(d.aB); }); + testGroups.get("hashCodeB").put("hashCodeB_Arrays", i -> { return hashCodeB_Arrays(d.aB); }); + testGroups.get("hashCodeB").put("hashCodeB_VectorAPI_v1", i -> { return hashCodeB_VectorAPI_v1(d.aB); }); + testGroups.get("hashCodeB").put("hashCodeB_VectorAPI_v2", i -> { return hashCodeB_VectorAPI_v2(d.aB); }); + + testGroups.put("scanAddI", new HashMap()); + testGroups.get("scanAddI").put("scanAddI_loop", i -> { return scanAddI_loop(d.aI, d.rI1); }); + testGroups.get("scanAddI").put("scanAddI_loop_reassociate", i -> { return scanAddI_loop_reassociate(d.aI, d.rI2); }); + testGroups.get("scanAddI").put("scanAddI_VectorAPI_permute_add", i -> { return scanAddI_VectorAPI_permute_add(d.aI, d.rI4); }); + + testGroups.put("findMinIndexI", new HashMap()); + testGroups.get("findMinIndexI").put("findMinIndexI_loop", i -> { return findMinIndexI_loop(d.aI); }); + testGroups.get("findMinIndexI").put("findMinIndexI_VectorAPI", i -> { return findMinIndexI_VectorAPI(d.aI); }); + + testGroups.put("findI", new HashMap()); + testGroups.get("findI").put("findI_loop", i -> { return findI_loop(d.aI, d.eI[i]); }); + testGroups.get("findI").put("findI_VectorAPI", i -> { return findI_VectorAPI(d.aI, d.eI[i]); }); + + testGroups.put("reverseI", new HashMap()); + testGroups.get("reverseI").put("reverseI_loop", i -> { return reverseI_loop(d.aI, d.rI1); }); + testGroups.get("reverseI").put("reverseI_VectorAPI", i -> { return reverseI_VectorAPI(d.aI, d.rI2); }); + + testGroups.put("filterI", new HashMap()); + testGroups.get("filterI").put("filterI_loop", i -> { return filterI_loop(d.aI, d.rI1, d.eI[i]); }); + testGroups.get("filterI").put("filterI_VectorAPI", i -> { return filterI_VectorAPI(d.aI, d.rI2, d.eI[i]); }); + + testGroups.put("reduceAddIFieldsX4", new HashMap()); + testGroups.get("reduceAddIFieldsX4").put("reduceAddIFieldsX4_loop", i -> { return reduceAddIFieldsX4_loop(d.oopsX4, d.memX4); }); + testGroups.get("reduceAddIFieldsX4").put("reduceAddIFieldsX4_VectorAPI", i -> { return reduceAddIFieldsX4_VectorAPI(d.oopsX4, d.memX4); }); + + testGroups.put("lowerCaseB", new HashMap()); + testGroups.get("lowerCaseB").put("lowerCaseB_loop", i -> { return lowerCaseB_loop(d.strB, d.rB1); }); + testGroups.get("lowerCaseB").put("lowerCaseB_VectorAPI_v1", i -> { return lowerCaseB_VectorAPI_v1(d.strB, d.rB2); }); + testGroups.get("lowerCaseB").put("lowerCaseB_VectorAPI_v2", i -> { return lowerCaseB_VectorAPI_v2(d.strB, d.rB3); }); + } + + @Warmup(100) + @Run(test = {"fillI_loop", + "fillI_VectorAPI", + "fillI_Arrays", + "iotaI_loop", + "iotaI_VectorAPI", + "copyI_loop", + "copyI_VectorAPI", + "copyI_System_arraycopy", + "mapI_loop", + "mapI_VectorAPI", + "reduceAddI_loop", + "reduceAddI_reassociate", + "reduceAddI_VectorAPI_naive", + "reduceAddI_VectorAPI_reduction_after_loop", + "dotProductF_loop", + "dotProductF_VectorAPI_naive", + "dotProductF_VectorAPI_reduction_after_loop", + "hashCodeB_loop", + "hashCodeB_Arrays", + "hashCodeB_VectorAPI_v1", + "hashCodeB_VectorAPI_v2", + "scanAddI_loop", + "scanAddI_loop_reassociate", + "scanAddI_VectorAPI_permute_add", + "findMinIndexI_loop", + "findMinIndexI_VectorAPI", + "findI_loop", + "findI_VectorAPI", + "reverseI_loop", + "reverseI_VectorAPI", + "filterI_loop", + "filterI_VectorAPI", + "reduceAddIFieldsX4_loop", + "reduceAddIFieldsX4_VectorAPI", + "lowerCaseB_loop", + "lowerCaseB_VectorAPI_v1", + "lowerCaseB_VectorAPI_v2"}) + public void runTests(RunInfo info) { + // Repeat many times, so that we also have multiple iterations for post-warmup to potentially recompile + int iters = info.isWarmUp() ? 1 : 20; + for (int iter = 0; iter < iters; iter++) { + // Set up random inputs, random size is important to stress tails. + int size = 100_000 + RANDOM.nextInt(10_000); + int seed = RANDOM.nextInt(); + int numXObjects = 10_000; + d = new VectorAlgorithmsImpl.Data(size, seed, numXObjects); + + // Run all tests + for (Map.Entry> group_entry : testGroups.entrySet()) { + String group_name = group_entry.getKey(); + Map group = group_entry.getValue(); + Object gold = null; + String gold_name = "NONE"; + for (Map.Entry entry : group.entrySet()) { + String name = entry.getKey(); + TestFunction test = entry.getValue(); + Object result = test.run(iter); + if (gold == null) { + gold = result; + gold_name = name; + } else { + try { + Verify.checkEQ(gold, result); + } catch (VerifyException e) { + throw new RuntimeException("Verify.checkEQ failed for group " + group_name + + ", gold " + gold_name + ", test " + name, e); + } + } + } + } + } + } + + @Test + @IR(counts = {IRNode.REPLICATE_I, "= 1", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIfAnd = {"UseSuperWord", "true", "OptimizeFill", "false"}) + @IR(counts = {".*CallLeafNoFP.*jint_fill.*", "= 1"}, + phase = CompilePhase.BEFORE_MATCHING, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIf = {"OptimizeFill", "true"}) + // By default, the fill intrinsic "jint_fill" is used, but we can disable + // the detection of the fill loop, and then we auto vectorize. + public Object fillI_loop(int[] r) { + return VectorAlgorithmsImpl.fillI_loop(r); + } + + @Test + @IR(counts = {IRNode.REPLICATE_I, "= 1", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object fillI_VectorAPI(int[] r) { + return VectorAlgorithmsImpl.fillI_VectorAPI(r); + } + + @Test + // Arrays.fill is not necessarily inlined, so we can't check + // for vectors in the IR. + public Object fillI_Arrays(int[] r) { + return VectorAlgorithmsImpl.fillI_Arrays(r); + } + + @Test + @IR(counts = {IRNode.POPULATE_INDEX, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"}, + applyIf = {"UseSuperWord", "true"}) + // Note: the Vector API example below can also vectorize for AVX, + // because it does not use a PopulateIndex. + public Object iotaI_loop(int[] r) { + return VectorAlgorithmsImpl.iotaI_loop(r); + } + + @Test + @IR(counts = {IRNode.ADD_VI, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeature = {"sse4.1", "true"}) + // Note: also works with NEON/asimd, but only with TieredCompilation. + public Object iotaI_VectorAPI(int[] r) { + return VectorAlgorithmsImpl.iotaI_VectorAPI(r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIf = {"UseSuperWord", "true"}) + public Object copyI_loop(int[] a, int[] r) { + return VectorAlgorithmsImpl.copyI_loop(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object copyI_VectorAPI(int[] a, int[] r) { + return VectorAlgorithmsImpl.copyI_VectorAPI(a, r); + } + + @Test + @IR(counts = {".*CallLeafNoFP.*jint_disjoint_arraycopy.*", "= 1"}, + phase = CompilePhase.BEFORE_MATCHING, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object copyI_System_arraycopy(int[] a, int[] r) { + return VectorAlgorithmsImpl.copyI_System_arraycopy(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.MUL_VI, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIf = {"UseSuperWord", "true"}) + public Object mapI_loop(int[] a, int[] r) { + return VectorAlgorithmsImpl.mapI_loop(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.MUL_VI, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object mapI_VectorAPI(int[] a, int[] r) { + return VectorAlgorithmsImpl.mapI_VectorAPI(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0", + IRNode.ADD_VI, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIf = {"UseSuperWord", "true"}) + public int reduceAddI_loop(int[] a) { + return VectorAlgorithmsImpl.reduceAddI_loop(a); + } + + @Test + public int reduceAddI_reassociate(int[] a) { + return VectorAlgorithmsImpl.reduceAddI_reassociate(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0"}, // reduceLanes inside loop + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public int reduceAddI_VectorAPI_naive(int[] a) { + return VectorAlgorithmsImpl.reduceAddI_VectorAPI_naive(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_F, "> 0", + IRNode.ADD_REDUCTION_V, "> 0", + IRNode.MUL_VF, "> 0"}, + applyIfCPUFeature = {"sse4.1", "true"}, + applyIf = {"UseSuperWord", "true"}) + // See also TestReduction.floatAddDotProduct + public float dotProductF_loop(float[] a, float[] b) { + return VectorAlgorithmsImpl.dotProductF_loop(a, b); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_F, "> 0", + IRNode.ADD_REDUCTION_V, "> 0", + IRNode.MUL_VF, "> 0"}, + applyIfCPUFeature = {"sse4.1", "true"}, + applyIf = {"UseSuperWord", "true"}) + public float dotProductF_VectorAPI_naive(float[] a, float[] b) { + return VectorAlgorithmsImpl.dotProductF_VectorAPI_naive(a, b); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_F, "> 0", + IRNode.ADD_REDUCTION_V, "> 0", + IRNode.MUL_VF, "> 0"}, + applyIfCPUFeature = {"sse4.1", "true"}, + applyIf = {"UseSuperWord", "true"}) + public float dotProductF_VectorAPI_reduction_after_loop(float[] a, float[] b) { + return VectorAlgorithmsImpl.dotProductF_VectorAPI_reduction_after_loop(a, b); + } + + @Test + public int hashCodeB_loop(byte[] a) { + return VectorAlgorithmsImpl.hashCodeB_loop(a); + } + + @Test + public int hashCodeB_Arrays(byte[] a) { + return VectorAlgorithmsImpl.hashCodeB_Arrays(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_B, IRNode.VECTOR_SIZE_8, "> 0", + IRNode.VECTOR_CAST_B2I, IRNode.VECTOR_SIZE_8, "> 0", + IRNode.MUL_VI, IRNode.VECTOR_SIZE_8, "> 0", + IRNode.ADD_VI, IRNode.VECTOR_SIZE_8, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0"}, + applyIfCPUFeature = {"avx2", "true"}) + public int hashCodeB_VectorAPI_v1(byte[] a) { + return VectorAlgorithmsImpl.hashCodeB_VectorAPI_v1(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_B, "> 0", + IRNode.MUL_VI, "> 0", + IRNode.ADD_VI, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0"}, + applyIfCPUFeature = {"avx2", "true"}) + public int hashCodeB_VectorAPI_v2(byte[] a) { + return VectorAlgorithmsImpl.hashCodeB_VectorAPI_v2(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0", + IRNode.ADD_VI, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public int reduceAddI_VectorAPI_reduction_after_loop(int[] a) { + return VectorAlgorithmsImpl.reduceAddI_VectorAPI_reduction_after_loop(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0", + IRNode.STORE_VECTOR, "= 0"}) + // Currently does not vectorize, but might in the future. + public Object scanAddI_loop(int[] a, int[] r) { + return VectorAlgorithmsImpl.scanAddI_loop(a, r); + } + + @Test + public Object scanAddI_loop_reassociate(int[] a, int[] r) { + return VectorAlgorithmsImpl.scanAddI_loop_reassociate(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.REARRANGE_VI, "> 0", + IRNode.AND_VI, "> 0", + IRNode.ADD_VI, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}, + applyIf = {"MaxVectorSize", ">=64"}) + public Object scanAddI_VectorAPI_permute_add(int[] a, int[] r) { + return VectorAlgorithmsImpl.scanAddI_VectorAPI_permute_add(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0"}) + // Currently does not vectorize, but might in the future. + public int findMinIndexI_loop(int[] a) { + return VectorAlgorithmsImpl.findMinIndexI_loop(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.VECTOR_MASK_CMP, "> 0", + IRNode.VECTOR_BLEND_I, "> 0", + IRNode.MIN_REDUCTION_V, "> 0", + IRNode.ADD_VI, "> 0"}, + applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"}) + public int findMinIndexI_VectorAPI(int[] a) { + return VectorAlgorithmsImpl.findMinIndexI_VectorAPI(a); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0"}) + // Currently does not vectorize, but might in the future. + public int findI_loop(int[] a, int e) { + return VectorAlgorithmsImpl.findI_loop(a, e); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.VECTOR_MASK_CMP, "> 0", + IRNode.VECTOR_TEST, "> 0"}, + applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"}) + public int findI_VectorAPI(int[] a, int e) { + return VectorAlgorithmsImpl.findI_VectorAPI(a, e); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0", + IRNode.STORE_VECTOR, "= 0"}) + // Currently does not vectorize, but might in the future. + public Object reverseI_loop(int[] a, int[] r) { + return VectorAlgorithmsImpl.reverseI_loop(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.REARRANGE_VI, "> 0", + IRNode.AND_VI, "> 0", + IRNode.STORE_VECTOR, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object reverseI_VectorAPI(int[] a, int[] r) { + return VectorAlgorithmsImpl.reverseI_VectorAPI(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0", + IRNode.STORE_VECTOR, "= 0"}) + public Object filterI_loop(int[] a, int[] r, int threshold) { + return VectorAlgorithmsImpl.filterI_loop(a, r, threshold); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.VECTOR_MASK_CMP, "> 0", + IRNode.VECTOR_TEST, "> 0", + IRNode.COMPRESS_VI, "> 0", + IRNode.STORE_VECTOR_MASKED, "> 0"}, + applyIfCPUFeature = {"avx2", "true"}) + public Object filterI_VectorAPI(int[] a, int[] r, int threshold) { + return VectorAlgorithmsImpl.filterI_VectorAPI(a, r, threshold); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0"}) + // Currently does not vectorize, but might in the future. + public int reduceAddIFieldsX4_loop(int[] oops, int[] mem) { + return VectorAlgorithmsImpl.reduceAddIFieldsX4_loop(oops, mem); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0", + IRNode.VECTOR_MASK_CMP, "> 0", + IRNode.VECTOR_TEST, "> 0", + IRNode.LOAD_VECTOR_GATHER_MASKED, "> 0", + IRNode.OR_V_MASK, "> 0", + IRNode.ADD_VI, "> 0", + IRNode.ADD_REDUCTION_VI, "> 0"}, + applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"}) + public int reduceAddIFieldsX4_VectorAPI(int[] oops, int[] mem) { + return VectorAlgorithmsImpl.reduceAddIFieldsX4_VectorAPI(oops, mem); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_B, "= 0"}) + // Currently does not vectorize, but might in the future. + public Object lowerCaseB_loop(byte[] a, byte[] r) { + return VectorAlgorithmsImpl.lowerCaseB_loop(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_B, "> 0", + IRNode.ADD_VB, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object lowerCaseB_VectorAPI_v1(byte[] a, byte[] r) { + return VectorAlgorithmsImpl.lowerCaseB_VectorAPI_v1(a, r); + } + + @Test + @IR(counts = {IRNode.LOAD_VECTOR_B, "> 0", + IRNode.ADD_VB, "> 0"}, + applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) + public Object lowerCaseB_VectorAPI_v2(byte[] a, byte[] r) { + return VectorAlgorithmsImpl.lowerCaseB_VectorAPI_v2(a, r); + } +} diff --git a/test/hotspot/jtreg/compiler/vectorization/VectorAlgorithmsImpl.java b/test/hotspot/jtreg/compiler/vectorization/VectorAlgorithmsImpl.java new file mode 100644 index 00000000000..2dfac704069 --- /dev/null +++ b/test/hotspot/jtreg/compiler/vectorization/VectorAlgorithmsImpl.java @@ -0,0 +1,774 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +package compiler.vectorization; + +import java.util.Arrays; +import java.util.Random; +import jdk.incubator.vector.*; + +/** + * The code below is supposed to be an exact copy of: + * micro/org/openjdk/bench/vm/compiler/VectorAlgorithmsImpl.java + */ +public class VectorAlgorithmsImpl { + private static final VectorSpecies SPECIES_I = IntVector.SPECIES_PREFERRED; + private static final VectorSpecies SPECIES_I512 = IntVector.SPECIES_512; + private static final VectorSpecies SPECIES_I256 = IntVector.SPECIES_256; + private static final VectorSpecies SPECIES_B = ByteVector.SPECIES_PREFERRED; + private static final VectorSpecies SPECIES_B64 = ByteVector.SPECIES_64; + private static final VectorSpecies SPECIES_F = FloatVector.SPECIES_PREFERRED; + + // This class stores the input and output arrays. + // The constructor sets up all the data. + // + // IMPORTANT: + // If you want to use some array but do NOT modify it: just use it. + // If you want to use it and DO want to modify it: clone it. This + // ensures that each test gets a separate copy, and that when we + // capture the modified arrays they are different for every method + // and run. + // An alternative to cloning is to use different return arrays for + // different implementations of the same group, e.g. rI1, rI2, ... + // + public static class Data { + public int[] aI; + public int[] rI1; + public int[] rI2; + public int[] rI3; + public int[] rI4; + public int[] eI; + // The test has to use the same index into eI for all implementations. But in the + // benchmark, we'd like to use random indices, so we use the index to advance through + // the array. + public int eI_idx = 0; + + public float[] aF; + public float[] bF; + + public byte[] aB; + public byte[] strB; + public byte[] rB1; + public byte[] rB2; + public byte[] rB3; + + public int[] oopsX4; + public int[] memX4; + + public Data(int size, int seed, int numX4Objects) { + Random random = new Random(seed); + + // int: one input array and multiple output arrays so different implementations can + // store their results to different arrays. + aI = new int[size]; + rI1 = new int[size]; + rI2 = new int[size]; + rI3 = new int[size]; + rI4 = new int[size]; + Arrays.setAll(aI, i -> random.nextInt()); + + // Populate with some random values from aI, and some totally random values. + eI = new int[0x10000]; + for (int i = 0; i < eI.length; i++) { + eI[i] = (random.nextInt(10) == 0) ? random.nextInt() : aI[random.nextInt(size)]; + } + + // X4 oop setup. + // oopsX4 holds "addresses" (i.e. indices), that point to the 16-byte objects in memX4. + oopsX4 = new int[size]; + memX4 = new int[numX4Objects * 4]; + for (int i = 0; i < size; i++) { + // assign either a zero=null, or assign a random oop. + oopsX4[i] = (random.nextInt(10) == 0) ? 0 : random.nextInt(numX4Objects) * 4; + } + // Just fill the whole array with random values. + // The relevant field is only at every "4 * i + 3" though. + memX4 = new int[4 * numX4Objects]; + for (int i = 0; i < memX4.length; i++) { + memX4[i] = random.nextInt(); + } + + // float inputs. To avoid rounding issues, only use small integers. + aF = new float[size]; + bF = new float[size]; + for (int i = 0; i < size; i++) { + aF[i] = random.nextInt(32) - 16; + bF[i] = random.nextInt(32) - 16; + } + + // byte: just random data. + aB = new byte[size]; + strB = new byte[size]; + rB1 = new byte[size]; + rB2 = new byte[size]; + rB3 = new byte[size]; + random.nextBytes(aB); + random.nextBytes(strB); // TODO: special data! + } + } + + public static Object fillI_loop(int[] r) { + for (int i = 0; i < r.length; i++) { + r[i] = 42; + } + return r; + } + + public static Object fillI_Arrays(int[] r) { + Arrays.fill(r, 42); + return r; + } + + public static Object fillI_VectorAPI(int[] r) { + var v = IntVector.broadcast(SPECIES_I, 42); + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = 42; + } + return r; + } + + public static Object iotaI_loop(int[] r) { + for (int i = 0; i < r.length; i++) { + r[i] = i; + } + return r; + } + + public static Object iotaI_VectorAPI(int[] r) { + var iota = IntVector.broadcast(SPECIES_I, 0).addIndex(1); + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + iota.intoArray(r, i); + iota = iota.add(SPECIES_I.length()); + } + for (; i < r.length; i++) { + r[i] = i; + } + return r; + } + + public static Object copyI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[i] = a[i]; + } + return r; + } + + public static Object copyI_System_arraycopy(int[] a, int[] r) { + System.arraycopy(a, 0, r, 0, a.length); + return r; + } + + public static Object copyI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = a[i]; + } + return r; + } + + public static Object mapI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[i] = a[i] * 42; + } + return r; + } + + public static Object mapI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v = v.mul(42); + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = a[i] * 42; + } + return r; + } + + public static int reduceAddI_loop(int[] a) { + int sum = 0; + for (int i = 0; i < a.length; i++) { + // Relying on simple reduction loop should vectorize since JDK26. + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_reassociate(int[] a) { + int sum = 0; + int i; + for (i = 0; i < a.length - 3; i += 4) { + // Unroll 4x, reassociate inside. + sum += a[i] + a[i + 1] + a[i + 2] + a[i + 3]; + } + for (; i < a.length; i++) { + // Tail + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_VectorAPI_naive(int[] a) { + var sum = 0; + int i; + for (i = 0; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + // reduceLanes in loop is better than scalar performance, but still + // relatively slow. + sum += v.reduceLanes(VectorOperators.ADD); + } + for (; i < a.length; i++) { + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_VectorAPI_reduction_after_loop(int[] a) { + var acc = IntVector.broadcast(SPECIES_I, 0); + int i; + for (i = 0; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + // Element-wide addition into a vector of partial sums is much faster. + // Now, we only need to do a reduceLanes after the loop. + // This works because int-addition is associative and commutative. + acc = acc.add(v); + } + int sum = acc.reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + sum += a[i]; + } + return sum; + } + + public static float dotProductF_loop(float[] a, float[] b) { + float sum = 0; + for (int i = 0; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static float dotProductF_VectorAPI_naive(float[] a, float[] b) { + float sum = 0; + int i; + for (i = 0; i < SPECIES_F.loopBound(a.length); i += SPECIES_F.length()) { + var va = FloatVector.fromArray(SPECIES_F, a, i); + var vb = FloatVector.fromArray(SPECIES_F, b, i); + sum += va.mul(vb).reduceLanes(VectorOperators.ADD); + } + for (; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static float dotProductF_VectorAPI_reduction_after_loop(float[] a, float[] b) { + var sums = FloatVector.broadcast(SPECIES_F, 0.0f); + int i; + for (i = 0; i < SPECIES_F.loopBound(a.length); i += SPECIES_F.length()) { + var va = FloatVector.fromArray(SPECIES_F, a, i); + var vb = FloatVector.fromArray(SPECIES_F, b, i); + sums = sums.add(va.mul(vb)); + } + float sum = sums.reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static int hashCodeB_loop(byte[] a) { + int h = 1; + for (int i = 0; i < a.length; i++) { + h = 31 * h + a[i]; + } + return h; + } + + public static int hashCodeB_Arrays(byte[] a) { + return Arrays.hashCode(a); + } + + // Simplified intrinsic code from C2_MacroAssembler::arrays_hashcode in c2_MacroAssembler_x86.cpp + // + // Ideas that may help understand the code: + // h(i) = 31 * h(i-1) + a[i] + // "unroll" by factor of L=8: + // h(i+8) = h(i) * 31^8 + a[i+1] * 31^7 + a[i+2] * 31^6 + ... + a[i+8] * 1 + // ----------- ------------------------------------------------ + // scalar vector: notice the powers of 31 in reverse + // + // We notice that we can load a[i+1 .. i+8], then element-wise multiply with + // the vector of reversed powers-of-31, and then do reduceLanes(ADD). + // But we can do even better: By looking at multiple such 8-unrolled iterations. + // Instead of applying the "next" factor of "31^8" to the reduced scalar, we can + // already apply it element-wise. That allows us to move the reduction out + // of the loop. + // + // Note: the intrinsic additionally unrolls the loop by a factor of 4, + // but we want to keep thins simple for demonstration purposes. + // + private static int[] REVERSE_POWERS_OF_31 = new int[9]; + static { + int p = 1; + for (int i = REVERSE_POWERS_OF_31.length - 1; i >= 0; i--) { + REVERSE_POWERS_OF_31[i] = p; + p *= 31; + } + } + public static int hashCodeB_VectorAPI_v1(byte[] a) { + int result = 1; // initialValue + var vresult = IntVector.zero(SPECIES_I256); + int next = REVERSE_POWERS_OF_31[0]; // 31^L + var vcoef = IntVector.fromArray(SPECIES_I256, REVERSE_POWERS_OF_31, 1); // powers of 2 in reverse + int i; + for (i = 0; i < SPECIES_B64.loopBound(a.length); i += SPECIES_B64.length()) { + // scalar part: result *= 31^L + result *= next; + // vector part: element-wise apply the next factor and add in the new values. + var vb = ByteVector.fromArray(SPECIES_B64, a, i); + var vi = vb.castShape(SPECIES_I256, 0); + vresult = vresult.mul(next).add(vi); + } + // reduce the partial hashes in the elements, using the reverse list of powers of 2. + result += vresult.mul(vcoef).reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + result = 31 * result + a[i]; + } + return result; + } + + // This second approach follows the idea from this blog post by Otmar Ertl: + // https://www.dynatrace.com/news/blog/java-arrays-hashcode-byte-efficiency-techniques/ + // + // I simplified the algorithm a little, so that it is a bit closer + // to the solution "v1" above. + // + // The major issue with "v1" is that we cannot load a full vector of bytes, + // because of the cast to ints. So we can only fill 1/4 of the maximal + // vector size. The trick here is to do an unrolling of factor 4, from: + // h(i) = 31 * h(i-1) + a[i] + // to: + // h(i+4) = h(i) * 31^4 + a[i + 1] * 31^3 + // + a[i + 2] * 31^2 + // + a[i + 3] * 31^1 + // + a[i + 4] * 31^0 + // The goal is now to compute this value for 4 bytes within a 4 byte + // lane of the vector. One concern is that we start with byte values, + // but need to do int-multiplication with powers of 31. If we instead + // did a byte-multiplication, we could get overflows that we would not + // have had in the int-multiplication. + // One trick that helps with chaning the size of the lanes from byte + // to short to int is doing all operations with unsigned integers. That + // way, we can zero-extend instead of sign-bit extend. The first step + // is thus to convert the bytes into unsigned values. Since byte is in + // range [-128..128), doing "a[i+j] + 128" makes it a positive value, + // allowing for unsigned multiplication. + // h(i+4) = h(i) * 31^4 + a[i + 1] * 31^3 + // + a[i + 2] * 31^2 + // + a[i + 3] * 31^1 + // + a[i + 4] * 31^0 + // = h(i) * 31^4 + (a[i + 1] + 128 - 128) * 31^3 + // + (a[i + 2] + 128 - 128) * 31^2 + // + (a[i + 3] + 128 - 128) * 31^1 + // + (a[i + 4] + 128 - 128) * 31^0 + // = h(i) * 31^4 + (a[i + 1] + 128 ) * 31^3 + // + (a[i + 2] + 128 ) * 31^2 + // + (a[i + 3] + 128 ) * 31^1 + // + (a[i + 4] + 128 ) * 31^0 + // + -128 * (31^3 + 31^2 + 31^1 + 1) + // = h(i) * 31^4 + ((a[i + 1] + 128) * 31 + // + (a[i + 2] + 128 ) * 31^2 + // + ((a[i + 3] + 128) * 31 + // + (a[i + 4] + 128 ) + // + -128 * (31^3 + 31^2 + 31^1 + 1) + // + // Getting from the signed a[i] value to unsigned with +128, we can + // just xor with 0x80=128. Any numbers there in range [-128..0) are + // now in range [0..128). And any numbers that were in range [0..128) + // are now in unsigned range [128..255). What a neat trick! + // + // We then apply a byte->short transition where we crunch 2 bytes + // into one short, applying a multiplication with 31 to one of the + // two bytes. This multiplication cannot overflow in a short. + // then we apply a short->int transition where we crunch 2 shorts + // into one int, applying a multiplication with 31^2 to one of the + // two shorts. This multiplication cannot overflow in an int. + // + public static int hashCodeB_VectorAPI_v2(byte[] a) { + return HashCodeB_VectorAPI_V2.compute(a); + } + + private static class HashCodeB_VectorAPI_V2 { + private static final int L = Math.min(ByteVector.SPECIES_PREFERRED.length(), + IntVector.SPECIES_PREFERRED.length() * 4); + private static final VectorShape SHAPE = VectorShape.forBitSize(8 * L); + private static final VectorSpecies SPECIES_B = SHAPE.withLanes(byte.class); + private static final VectorSpecies SPECIES_I = SHAPE.withLanes(int.class); + + private static int[] REVERSE_POWERS_OF_31_STEP_4 = new int[L / 4 + 1]; + static { + int p = 1; + int step = 31 * 31 * 31 * 31; // step by 4 + for (int i = REVERSE_POWERS_OF_31_STEP_4.length - 1; i >= 0; i--) { + REVERSE_POWERS_OF_31_STEP_4[i] = p; + p *= step; + } + } + + public static int compute(byte[] a) { + int result = 1; // initialValue + int next = REVERSE_POWERS_OF_31_STEP_4[0]; // 31^L + var vcoef = IntVector.fromArray(SPECIES_I, REVERSE_POWERS_OF_31_STEP_4, 1); // W + var vresult = IntVector.zero(SPECIES_I); + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vb = ByteVector.fromArray(SPECIES_B, a, i); + // Add 128 to each byte. + var vs = vb.lanewise(VectorOperators.XOR, (byte)0x80) + .reinterpretAsShorts(); + // Each short lane contains 2 bytes, crunch them. + var vi = vs.and((short)0xff) // lower byte + .mul((short)31) + .add(vs.lanewise(VectorOperators.LSHR, 8)) // upper byte + .reinterpretAsInts(); + // Each int contains 2 shorts, crunch them. + var v = vi.and(0xffff) // lower short + .mul(31 * 31) + .add(vi.lanewise(VectorOperators.LSHR, 16)); // upper short + // Add the correction for the 128 additions above. + v = v.add(-128 * (31*31*31 + 31*31 + 31 + 1)); + // Every element of v now contains a crunched int-package of 4 bytes. + result *= next; + vresult = vresult.mul(next).add(v); + } + result += vresult.mul(vcoef).reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + result = 31 * result + a[i]; + } + return result; + } + } + + public static Object scanAddI_loop(int[] a, int[] r) { + int sum = 0; + for (int i = 0; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static Object scanAddI_loop_reassociate(int[] a, int[] r) { + int sum = 0; + int i = 0; + for (; i < a.length - 3; i += 4) { + // We cut the latency by a factor of 4, but increase the number of additions. + int old_sum = sum; + int v0 = a[i + 0]; + int v1 = a[i + 1]; + int v2 = a[i + 2]; + int v3 = a[i + 3]; + int v01 = v0 + v1; + int v23 = v2 + v3; + int v0123 = v01 + v23; + sum += v0123; + r[i + 0] = old_sum + v0; + r[i + 1] = old_sum + v01; + r[i + 2] = old_sum + v01 + v2; + r[i + 3] = old_sum + v0123; + } + for (; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static Object scanAddI_VectorAPI_permute_add(int[] a, int[] r) { + // Using Naive Parallel Algorithm: Hills and Steele + int sum = 0; + int xx = 0; // masked later anyway + var shf1 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 0); + var shf2 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 0); + var shf3 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, xx, xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 0); + var shf4 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, xx, xx, xx, xx, xx, xx, 0, 1, 2, 3, 4, 5, 6, 7}, 0); + var mask1 = VectorMask.fromLong(SPECIES_I512, 0b1111111111111110); + var mask2 = VectorMask.fromLong(SPECIES_I512, 0b1111111111111100); + var mask3 = VectorMask.fromLong(SPECIES_I512, 0b1111111111110000); + var mask4 = VectorMask.fromLong(SPECIES_I512, 0b1111111100000000); + int i = 0; + for (; i < SPECIES_I512.loopBound(a.length); i += SPECIES_I512.length()) { + IntVector v = IntVector.fromArray(SPECIES_I512, a, i); + v = v.add(v.rearrange(shf1), mask1); + v = v.add(v.rearrange(shf2), mask2); + v = v.add(v.rearrange(shf3), mask3); + v = v.add(v.rearrange(shf4), mask4); + v = v.add(sum); + v.intoArray(r, i); + sum = v.lane(SPECIES_I512.length() - 1); + } + for (; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static int findMinIndexI_loop(int[] a) { + int min = a[0]; + int index = 0; + for (int i = 1; i < a.length; i++) { + int ai = a[i]; + if (ai < min) { + min = ai; + index = i; + } + } + return index; + } + + public static int findMinIndexI_VectorAPI(int[] a) { + // Main approach: have partial results in mins and idxs. + var mins = IntVector.broadcast(SPECIES_I, a[0]); + var idxs = IntVector.broadcast(SPECIES_I, 0); + var iota = IntVector.broadcast(SPECIES_I, 0).addIndex(1); + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.LT, mins); + mins = mins.blend(v, mask); + idxs = idxs.blend(iota, mask); + iota = iota.add(SPECIES_I.length()); + } + // Reduce the vectors down + int min = mins.reduceLanes(VectorOperators.MIN); + var not_min_mask = mins.compare(VectorOperators.NE, min); + int index = idxs.blend(a.length, not_min_mask).reduceLanes(VectorOperators.MIN); + // Tail loop + for (; i < a.length; i++) { + int ai = a[i]; + if (ai < min) { + min = ai; + index = i; + } + } + return index; + } + + public static int findI_loop(int[] a, int e) { + for (int i = 0; i < a.length; i++) { + int ai = a[i]; + if (ai == e) { + return i; + } + } + return -1; + } + + public static int findI_VectorAPI(int[] a, int e) { + var es = IntVector.broadcast(SPECIES_I, e); + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.EQ, es); + if (mask.anyTrue()) { + return i + mask.firstTrue(); + } + } + for (; i < a.length; i++) { + int ai = a[i]; + if (ai == e) { + return i; + } + } + return -1; + } + + public static Object reverseI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[a.length - i - 1] = a[i]; + } + return r; + } + + private static final VectorShuffle REVERSE_SHUFFLE_I = SPECIES_I.iotaShuffle(SPECIES_I.length()-1, -1, true); + + public static Object reverseI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v = v.rearrange(REVERSE_SHUFFLE_I); + v.intoArray(r, r.length - SPECIES_I.length() - i); + } + for (; i < a.length; i++) { + r[a.length - i - 1] = a[i]; + } + return r; + } + + public static Object filterI_loop(int[] a, int[] r, int threshold) { + int j = 0; + for (int i = 0; i < a.length; i++) { + int ai = a[i]; + if (ai >= threshold) { + r[j++] = ai; + } + } + // Just force the resulting length onto the same array. + r[r.length - 1] = j; + return r; + } + + public static Object filterI_VectorAPI(int[] a, int[] r, int threshold) { + var thresholds = IntVector.broadcast(SPECIES_I, threshold); + int j = 0; + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.GE, thresholds); + v = v.compress(mask); + int trueCount = mask.trueCount(); + var prefixMask = mask.compress(); + v.intoArray(r, j, prefixMask); + j += trueCount; + } + + for (; i < a.length; i++) { + int ai = a[i]; + if (ai >= threshold) { + r[j++] = ai; + } + } + // Just force the resulting length onto the same array. + r[r.length - 1] = j; + return r; + } + + // X4: ints simulate 4-byte oops. + // oops: if non-zero (= non-null), every entry simulates a 4-byte oop, pointing into mem. + // mem: an int array that simulates the memory. + // + // Task: Find all non-null oops, and dereference them, get the relevant field. + // Objects have 16 bytes, and the relevant field is at bytes 12-16. + // That maps to 4 ints, and the relevant field is the 4th element of 4. + // Sum up all the field values. + public static int reduceAddIFieldsX4_loop(int[] oops, int[] mem) { + int sum = 0; + for (int i = 0; i < oops.length; i++) { + int oop = oops[i]; + if (oop != 0) { + int fieldValue = mem[oop + 3]; // oop+12 + sum += fieldValue; + } + } + return sum; + } + + public static int reduceAddIFieldsX4_VectorAPI(int[] oops, int[] mem) { + var acc = IntVector.broadcast(SPECIES_I, 0); + int i = 0; + for (; i < SPECIES_I.loopBound(oops.length); i += SPECIES_I.length()) { + var oopv = IntVector.fromArray(SPECIES_I, oops, i); + var mask = oopv.compare(VectorOperators.NE, /* null */0); + // We are lucky today: we need to access mem[oop + 3] + var fieldValues = IntVector.fromArray(SPECIES_I, mem, 3, oops, i, mask); + acc = acc.add(fieldValues); + } + int sum = acc.reduceLanes(VectorOperators.ADD); + for (; i < oops.length; i++) { + int oop = oops[i]; + if (oop != 0) { + int fieldValue = mem[oop + 3]; // oop+12 + sum += fieldValue; + } + } + return sum; + } + + // The lowerCase example demonstrates a lane-wise control-flow diamond. + public static Object lowerCaseB_loop(byte[] a, byte[] r) { + for (int i = 0; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); // c += 32 + } + r[i] = c; + } + return r; + } + + // Control-flow diamonds can easily be simulated by "if-conversion", i.e. + // by using masked operations. An alternative would be to use blend. + public static Object lowerCaseB_VectorAPI_v1(byte[] a, byte[] r) { + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vc = ByteVector.fromArray(SPECIES_B, a, i); + var maskA = vc.compare(VectorOperators.GE, (byte)'A'); + var maskZ = vc.compare(VectorOperators.LE, (byte)'Z'); + var mask = maskA.and(maskZ); + vc = vc.add((byte)32, mask); + vc.intoArray(r, i); + } + for (; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); + } + r[i] = c; + } + return r; + } + + public static Object lowerCaseB_VectorAPI_v2(byte[] a, byte[] r) { + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vc = ByteVector.fromArray(SPECIES_B, a, i); + // We can convert the range 65..90 (represents ascii A..Z) into a range 0..25. + // This allows us to only use a single unsigned comparison. + var vt = vc.add((byte)-'A'); + var mask = vt.compare(VectorOperators.ULE, (byte)25); + vc = vc.add((byte)32, mask); + vc.intoArray(r, i); + } + for (; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); + } + r[i] = c; + } + return r; + } +} diff --git a/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithms.java b/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithms.java new file mode 100644 index 00000000000..911494cb022 --- /dev/null +++ b/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithms.java @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +package org.openjdk.bench.vm.compiler; + +import java.util.Arrays; +import java.util.concurrent.TimeUnit; +import org.openjdk.jmh.annotations.*; + +/** + * The goal of this benchmark is to show the power of auto vectorization + * and the Vector API. + * + * Please only modify this benchark in synchronization with the IR test: + * test/hotspot/jtreg/compiler/vectorization/TestVectorAlgorithms.java + * + * You may want to play with the following VM flags: + * - Disable auto vectorization: + * -XX:+UnlockDiagnosticVMOptions -XX:AutoVectorizationOverrideProfitability=0 + * - Smaller vector size: + * -XX:MaxVectorSize=16 + * - Disable fill loop detection, so we don't use intrinsic but auto vectorization: + * -XX:-OptimizeFill + * - Lilliput can also have an effect, because it can change alignment and have + * an impact on which exact intrinsic is chosen (e.g. fill and copy): + * -XX:+UseCompactObjectHeaders + */ +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Thread) +@Warmup(iterations = 5, time = 1) +@Measurement(iterations = 3, time = 1) +@Fork(value = 5, jvmArgs = {"--add-modules=jdk.incubator.vector", "-XX:CompileCommand=inline,*VectorAlgorithmsImpl*::*"}) +public class VectorAlgorithms { + @Param({"640000"}) + public int SIZE; + + @Param({"10000"}) + public int NUM_X_OBJECTS; + + @Param({"0"}) + public int SEED; + + VectorAlgorithmsImpl.Data d; + + @Setup + public void init() { + d = new VectorAlgorithmsImpl.Data(SIZE, SEED, NUM_X_OBJECTS); + } + + // ------------------------------------------------------------------------------------------ + // Benchmarks just forward arguments and returns. + // ------------------------------------------------------------------------------------------ + + @Benchmark + public Object fillI_loop() { + return VectorAlgorithmsImpl.fillI_loop(d.rI1); + } + + @Benchmark + public Object fillI_VectorAPI() { + return VectorAlgorithmsImpl.fillI_VectorAPI(d.rI1); + } + + @Benchmark + public Object fillI_Arrays() { + return VectorAlgorithmsImpl.fillI_Arrays(d.rI1); + } + + @Benchmark + public Object iotaI_loop() { + return VectorAlgorithmsImpl.iotaI_loop(d.rI1); + } + + @Benchmark + public Object iotaI_VectorAPI() { + return VectorAlgorithmsImpl.iotaI_VectorAPI(d.rI1); + } + + @Benchmark + public Object copyI_loop() { + return VectorAlgorithmsImpl.copyI_loop(d.aI, d.rI1); + } + + @Benchmark + public Object copyI_VectorAPI() { + return VectorAlgorithmsImpl.copyI_VectorAPI(d.aI, d.rI1); + } + + @Benchmark + public Object copyI_System_arraycopy() { + return VectorAlgorithmsImpl.copyI_System_arraycopy(d.aI, d.rI1); + } + + @Benchmark + public Object mapI_loop() { + return VectorAlgorithmsImpl.mapI_loop(d.aI, d.rI1); + } + + @Benchmark + public Object mapI_VectorAPI() { + return VectorAlgorithmsImpl.mapI_VectorAPI(d.aI, d.rI1); + } + + @Benchmark + public int reduceAddI_loop() { + return VectorAlgorithmsImpl.reduceAddI_loop(d.aI); + } + + @Benchmark + public int reduceAddI_reassociate() { + return VectorAlgorithmsImpl.reduceAddI_reassociate(d.aI); + } + + @Benchmark + public int reduceAddI_VectorAPI_naive() { + return VectorAlgorithmsImpl.reduceAddI_VectorAPI_naive(d.aI); + } + + @Benchmark + public int reduceAddI_VectorAPI_reduction_after_loop() { + return VectorAlgorithmsImpl.reduceAddI_VectorAPI_reduction_after_loop(d.aI); + } + + @Benchmark + public float dotProductF_loop() { + return VectorAlgorithmsImpl.dotProductF_loop(d.aF, d.bF); + } + + @Benchmark + public float dotProductF_VectorAPI_naive() { + return VectorAlgorithmsImpl.dotProductF_VectorAPI_naive(d.aF, d.bF); + } + + @Benchmark + public float dotProductF_VectorAPI_reduction_after_loop() { + return VectorAlgorithmsImpl.dotProductF_VectorAPI_reduction_after_loop(d.aF, d.bF); + } + + @Benchmark + public int hashCodeB_loop() { + return VectorAlgorithmsImpl.hashCodeB_loop(d.aB); + } + + @Benchmark + public int hashCodeB_Arrays() { + return VectorAlgorithmsImpl.hashCodeB_Arrays(d.aB); + } + + @Benchmark + public int hashCodeB_VectorAPI_v1() { + return VectorAlgorithmsImpl.hashCodeB_VectorAPI_v1(d.aB); + } + + @Benchmark + public int hashCodeB_VectorAPI_v2() { + return VectorAlgorithmsImpl.hashCodeB_VectorAPI_v2(d.aB); + } + + @Benchmark + public Object scanAddI_loop() { + return VectorAlgorithmsImpl.scanAddI_loop(d.aI, d.rI1); + } + + @Benchmark + public Object scanAddI_loop_reassociate() { + return VectorAlgorithmsImpl.scanAddI_loop_reassociate(d.aI, d.rI1); + } + + @Benchmark + public Object scanAddI_VectorAPI_permute_add() { + return VectorAlgorithmsImpl.scanAddI_VectorAPI_permute_add(d.aI, d.rI1); + } + + @Benchmark + public int findMinIndexI_loop() { + return VectorAlgorithmsImpl.findMinIndexI_loop(d.aI); + } + + @Benchmark + public int findMinIndexI_VectorAPI() { + return VectorAlgorithmsImpl.findMinIndexI_VectorAPI(d.aI); + } + + @Benchmark + public int findI_loop() { + // Every invocation should have a different value for e, so that + // we don't get branch-prediction that is too good. And also so + // that the position where we exit is more evenly distributed. + d.eI_idx = (d.eI_idx + 1) & 0xffff; + int e = d.eI[d.eI_idx]; + return VectorAlgorithmsImpl.findI_loop(d.aI, e); + } + + @Benchmark + public int findI_VectorAPI() { + d.eI_idx = (d.eI_idx + 1) & 0xffff; + int e = d.eI[d.eI_idx]; + return VectorAlgorithmsImpl.findI_VectorAPI(d.aI, e); + } + + @Benchmark + public Object reverseI_loop() { + return VectorAlgorithmsImpl.reverseI_loop(d.aI, d.rI1); + } + + @Benchmark + public Object reverseI_VectorAPI() { + return VectorAlgorithmsImpl.reverseI_VectorAPI(d.aI, d.rI1); + } + + @Benchmark + public Object filterI_loop() { + // Every invocation should have a different value for e, so that + // we don't get branch-prediction that is too good. And also so + // That the length of the resulting data is more evenly distributed. + d.eI_idx = (d.eI_idx + 1) & 0xffff; + int e = d.eI[d.eI_idx]; + return VectorAlgorithmsImpl.filterI_loop(d.aI, d.rI1, e); + } + + @Benchmark + public Object filterI_VectorAPI() { + d.eI_idx = (d.eI_idx + 1) & 0xffff; + int e = d.eI[d.eI_idx]; + return VectorAlgorithmsImpl.filterI_VectorAPI(d.aI, d.rI1, e); + } + + @Benchmark + public int reduceAddIFieldsX4_loop() { + return VectorAlgorithmsImpl.reduceAddIFieldsX4_loop(d.oopsX4, d.memX4); + } + + @Benchmark + public int reduceAddIFieldsX4_VectorAPI() { + return VectorAlgorithmsImpl.reduceAddIFieldsX4_VectorAPI(d.oopsX4, d.memX4); + } + + @Benchmark + public Object lowerCaseB_loop() { + return VectorAlgorithmsImpl.lowerCaseB_loop(d.strB, d.rB1); + } + + @Benchmark + public Object lowerCaseB_VectorAPI_v1() { + return VectorAlgorithmsImpl.lowerCaseB_VectorAPI_v1(d.strB, d.rB1); + } + + @Benchmark + public Object lowerCaseB_VectorAPI_v2() { + return VectorAlgorithmsImpl.lowerCaseB_VectorAPI_v2(d.strB, d.rB1); + } +} diff --git a/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithmsImpl.java b/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithmsImpl.java new file mode 100644 index 00000000000..5ab057329d3 --- /dev/null +++ b/test/micro/org/openjdk/bench/vm/compiler/VectorAlgorithmsImpl.java @@ -0,0 +1,775 @@ +/* + * Copyright (c) 2026, 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. + * + */ + +package org.openjdk.bench.vm.compiler; + +import java.util.Arrays; +import java.util.Random; +import jdk.incubator.vector.*; + +/** + * The code below is supposed to be an exact copy of: + * test/hotspot/jtreg/compiler/vectorization/VectorAlgorithmsImpl.java + */ +public class VectorAlgorithmsImpl { + private static final VectorSpecies SPECIES_I = IntVector.SPECIES_PREFERRED; + private static final VectorSpecies SPECIES_I512 = IntVector.SPECIES_512; + private static final VectorSpecies SPECIES_I256 = IntVector.SPECIES_256; + private static final VectorSpecies SPECIES_B = ByteVector.SPECIES_PREFERRED; + private static final VectorSpecies SPECIES_B64 = ByteVector.SPECIES_64; + private static final VectorSpecies SPECIES_F = FloatVector.SPECIES_PREFERRED; + + // This class stores the input and output arrays. + // The constructor sets up all the data. + // + // IMPORTANT: + // If you want to use some array but do NOT modify it: just use it. + // If you want to use it and DO want to modify it: clone it. This + // ensures that each test gets a separate copy, and that when we + // capture the modified arrays they are different for every method + // and run. + // An alternative to cloning is to use different return arrays for + // different implementations of the same group, e.g. rI1, rI2, ... + // + public static class Data { + public int[] aI; + public int[] rI1; + public int[] rI2; + public int[] rI3; + public int[] rI4; + public int[] eI; + // The test has to use the same index into eI for all implementations. But in the + // benchmark, we'd like to use random indices, so we use the index to advance through + // the array. + public int eI_idx = 0; + + public float[] aF; + public float[] bF; + + public byte[] aB; + public byte[] strB; + public byte[] rB1; + public byte[] rB2; + public byte[] rB3; + + public int[] oopsX4; + public int[] memX4; + + public Data(int size, int seed, int numX4Objects) { + Random random = new Random(seed); + + // int: one input array and multiple output arrays so different implementations can + // store their results to different arrays. + aI = new int[size]; + rI1 = new int[size]; + rI2 = new int[size]; + rI3 = new int[size]; + rI4 = new int[size]; + Arrays.setAll(aI, i -> random.nextInt()); + + // Populate with some random values from aI, and some totally random values. + eI = new int[0x10000]; + for (int i = 0; i < eI.length; i++) { + eI[i] = (random.nextInt(10) == 0) ? random.nextInt() : aI[random.nextInt(size)]; + } + + // X4 oop setup. + // oopsX4 holds "addresses" (i.e. indices), that point to the 16-byte objects in memX4. + oopsX4 = new int[size]; + memX4 = new int[numX4Objects * 4]; + for (int i = 0; i < size; i++) { + // assign either a zero=null, or assign a random oop. + oopsX4[i] = (random.nextInt(10) == 0) ? 0 : random.nextInt(numX4Objects) * 4; + } + // Just fill the whole array with random values. + // The relevant field is only at every "4 * i + 3" though. + memX4 = new int[4 * numX4Objects]; + for (int i = 0; i < memX4.length; i++) { + memX4[i] = random.nextInt(); + } + + // float inputs. To avoid rounding issues, only use small integers. + aF = new float[size]; + bF = new float[size]; + for (int i = 0; i < size; i++) { + aF[i] = random.nextInt(32) - 16; + bF[i] = random.nextInt(32) - 16; + } + + // byte: just random data. + aB = new byte[size]; + strB = new byte[size]; + rB1 = new byte[size]; + rB2 = new byte[size]; + rB3 = new byte[size]; + random.nextBytes(aB); + random.nextBytes(strB); // TODO: special data! + } + } + + public static Object fillI_loop(int[] r) { + for (int i = 0; i < r.length; i++) { + r[i] = 42; + } + return r; + } + + public static Object fillI_Arrays(int[] r) { + Arrays.fill(r, 42); + return r; + } + + public static Object fillI_VectorAPI(int[] r) { + var v = IntVector.broadcast(SPECIES_I, 42); + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = 42; + } + return r; + } + + public static Object iotaI_loop(int[] r) { + for (int i = 0; i < r.length; i++) { + r[i] = i; + } + return r; + } + + public static Object iotaI_VectorAPI(int[] r) { + var iota = IntVector.broadcast(SPECIES_I, 0).addIndex(1); + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + iota.intoArray(r, i); + iota = iota.add(SPECIES_I.length()); + } + for (; i < r.length; i++) { + r[i] = i; + } + return r; + } + + public static Object copyI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[i] = a[i]; + } + return r; + } + + public static Object copyI_System_arraycopy(int[] a, int[] r) { + System.arraycopy(a, 0, r, 0, a.length); + return r; + } + + public static Object copyI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = a[i]; + } + return r; + } + + public static Object mapI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[i] = a[i] * 42; + } + return r; + } + + public static Object mapI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(r.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v = v.mul(42); + v.intoArray(r, i); + } + for (; i < r.length; i++) { + r[i] = a[i] * 42; + } + return r; + } + + public static int reduceAddI_loop(int[] a) { + int sum = 0; + for (int i = 0; i < a.length; i++) { + // Relying on simple reduction loop should vectorize since JDK26. + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_reassociate(int[] a) { + int sum = 0; + int i; + for (i = 0; i < a.length - 3; i += 4) { + // Unroll 4x, reassociate inside. + sum += a[i] + a[i + 1] + a[i + 2] + a[i + 3]; + } + for (; i < a.length; i++) { + // Tail + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_VectorAPI_naive(int[] a) { + var sum = 0; + int i; + for (i = 0; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + // reduceLanes in loop is better than scalar performance, but still + // relatively slow. + sum += v.reduceLanes(VectorOperators.ADD); + } + for (; i < a.length; i++) { + sum += a[i]; + } + return sum; + } + + public static int reduceAddI_VectorAPI_reduction_after_loop(int[] a) { + var acc = IntVector.broadcast(SPECIES_I, 0); + int i; + for (i = 0; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + // Element-wide addition into a vector of partial sums is much faster. + // Now, we only need to do a reduceLanes after the loop. + // This works because int-addition is associative and commutative. + acc = acc.add(v); + } + int sum = acc.reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + sum += a[i]; + } + return sum; + } + + public static float dotProductF_loop(float[] a, float[] b) { + float sum = 0; + for (int i = 0; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static float dotProductF_VectorAPI_naive(float[] a, float[] b) { + float sum = 0; + int i; + for (i = 0; i < SPECIES_F.loopBound(a.length); i += SPECIES_F.length()) { + var va = FloatVector.fromArray(SPECIES_F, a, i); + var vb = FloatVector.fromArray(SPECIES_F, b, i); + sum += va.mul(vb).reduceLanes(VectorOperators.ADD); + } + for (; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static float dotProductF_VectorAPI_reduction_after_loop(float[] a, float[] b) { + var sums = FloatVector.broadcast(SPECIES_F, 0.0f); + int i; + for (i = 0; i < SPECIES_F.loopBound(a.length); i += SPECIES_F.length()) { + var va = FloatVector.fromArray(SPECIES_F, a, i); + var vb = FloatVector.fromArray(SPECIES_F, b, i); + sums = sums.add(va.mul(vb)); + } + float sum = sums.reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + sum += a[i] * b[i]; + } + return sum; + } + + public static int hashCodeB_loop(byte[] a) { + int h = 1; + for (int i = 0; i < a.length; i++) { + h = 31 * h + a[i]; + } + return h; + } + + public static int hashCodeB_Arrays(byte[] a) { + return Arrays.hashCode(a); + } + + // Simplified intrinsic code from C2_MacroAssembler::arrays_hashcode in c2_MacroAssembler_x86.cpp + // + // Ideas that may help understand the code: + // h(i) = 31 * h(i-1) + a[i] + // "unroll" by factor of L=8: + // h(i+8) = h(i) * 31^8 + a[i+1] * 31^7 + a[i+2] * 31^6 + ... + a[i+8] * 1 + // ----------- ------------------------------------------------ + // scalar vector: notice the powers of 31 in reverse + // + // We notice that we can load a[i+1 .. i+8], then element-wise multiply with + // the vector of reversed powers-of-31, and then do reduceLanes(ADD). + // But we can do even better: By looking at multiple such 8-unrolled iterations. + // Instead of applying the "next" factor of "31^8" to the reduced scalar, we can + // already apply it element-wise. That allows us to move the reduction out + // of the loop. + // + // Note: the intrinsic additionally unrolls the loop by a factor of 4, + // but we want to keep thins simple for demonstration purposes. + // + private static int[] REVERSE_POWERS_OF_31 = new int[9]; + static { + int p = 1; + for (int i = REVERSE_POWERS_OF_31.length - 1; i >= 0; i--) { + REVERSE_POWERS_OF_31[i] = p; + p *= 31; + } + } + public static int hashCodeB_VectorAPI_v1(byte[] a) { + int result = 1; // initialValue + var vresult = IntVector.zero(SPECIES_I256); + int next = REVERSE_POWERS_OF_31[0]; // 31^L + var vcoef = IntVector.fromArray(SPECIES_I256, REVERSE_POWERS_OF_31, 1); // powers of 2 in reverse + int i; + for (i = 0; i < SPECIES_B64.loopBound(a.length); i += SPECIES_B64.length()) { + // scalar part: result *= 31^L + result *= next; + // vector part: element-wise apply the next factor and add in the new values. + var vb = ByteVector.fromArray(SPECIES_B64, a, i); + var vi = vb.castShape(SPECIES_I256, 0); + vresult = vresult.mul(next).add(vi); + } + // reduce the partial hashes in the elements, using the reverse list of powers of 2. + result += vresult.mul(vcoef).reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + result = 31 * result + a[i]; + } + return result; + } + + // This second approach follows the idea from this blog post by Otmar Ertl: + // https://www.dynatrace.com/news/blog/java-arrays-hashcode-byte-efficiency-techniques/ + // + // I simplified the algorithm a little, so that it is a bit closer + // to the solution "v1" above. + // + // The major issue with "v1" is that we cannot load a full vector of bytes, + // because of the cast to ints. So we can only fill 1/4 of the maximal + // vector size. The trick here is to do an unrolling of factor 4, from: + // h(i) = 31 * h(i-1) + a[i] + // to: + // h(i+4) = h(i) * 31^4 + a[i + 1] * 31^3 + // + a[i + 2] * 31^2 + // + a[i + 3] * 31^1 + // + a[i + 4] * 31^0 + // The goal is now to compute this value for 4 bytes within a 4 byte + // lane of the vector. One concern is that we start with byte values, + // but need to do int-multiplication with powers of 31. If we instead + // did a byte-multiplication, we could get overflows that we would not + // have had in the int-multiplication. + // One trick that helps with chaning the size of the lanes from byte + // to short to int is doing all operations with unsigned integers. That + // way, we can zero-extend instead of sign-bit extend. The first step + // is thus to convert the bytes into unsigned values. Since byte is in + // range [-128..128), doing "a[i+j] + 128" makes it a positive value, + // allowing for unsigned multiplication. + // h(i+4) = h(i) * 31^4 + a[i + 1] * 31^3 + // + a[i + 2] * 31^2 + // + a[i + 3] * 31^1 + // + a[i + 4] * 31^0 + // = h(i) * 31^4 + (a[i + 1] + 128 - 128) * 31^3 + // + (a[i + 2] + 128 - 128) * 31^2 + // + (a[i + 3] + 128 - 128) * 31^1 + // + (a[i + 4] + 128 - 128) * 31^0 + // = h(i) * 31^4 + (a[i + 1] + 128 ) * 31^3 + // + (a[i + 2] + 128 ) * 31^2 + // + (a[i + 3] + 128 ) * 31^1 + // + (a[i + 4] + 128 ) * 31^0 + // + -128 * (31^3 + 31^2 + 31^1 + 1) + // = h(i) * 31^4 + ((a[i + 1] + 128) * 31 + // + (a[i + 2] + 128 ) * 31^2 + // + ((a[i + 3] + 128) * 31 + // + (a[i + 4] + 128 ) + // + -128 * (31^3 + 31^2 + 31^1 + 1) + // + // Getting from the signed a[i] value to unsigned with +128, we can + // just xor with 0x80=128. Any numbers there in range [-128..0) are + // now in range [0..128). And any numbers that were in range [0..128) + // are now in unsigned range [128..255). What a neat trick! + // + // We then apply a byte->short transition where we crunch 2 bytes + // into one short, applying a multiplication with 31 to one of the + // two bytes. This multiplication cannot overflow in a short. + // then we apply a short->int transition where we crunch 2 shorts + // into one int, applying a multiplication with 31^2 to one of the + // two shorts. This multiplication cannot overflow in an int. + // + public static int hashCodeB_VectorAPI_v2(byte[] a) { + return HashCodeB_VectorAPI_V2.compute(a); + } + + private static class HashCodeB_VectorAPI_V2 { + private static final int L = Math.min(ByteVector.SPECIES_PREFERRED.length(), + IntVector.SPECIES_PREFERRED.length() * 4); + private static final VectorShape SHAPE = VectorShape.forBitSize(8 * L); + private static final VectorSpecies SPECIES_B = SHAPE.withLanes(byte.class); + private static final VectorSpecies SPECIES_I = SHAPE.withLanes(int.class); + + private static int[] REVERSE_POWERS_OF_31_STEP_4 = new int[L / 4 + 1]; + static { + int p = 1; + int step = 31 * 31 * 31 * 31; // step by 4 + for (int i = REVERSE_POWERS_OF_31_STEP_4.length - 1; i >= 0; i--) { + REVERSE_POWERS_OF_31_STEP_4[i] = p; + p *= step; + } + } + + public static int compute(byte[] a) { + int result = 1; // initialValue + int next = REVERSE_POWERS_OF_31_STEP_4[0]; // 31^L + var vcoef = IntVector.fromArray(SPECIES_I, REVERSE_POWERS_OF_31_STEP_4, 1); // W + var vresult = IntVector.zero(SPECIES_I); + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vb = ByteVector.fromArray(SPECIES_B, a, i); + // Add 128 to each byte. + var vs = vb.lanewise(VectorOperators.XOR, (byte)0x80) + .reinterpretAsShorts(); + // Each short lane contains 2 bytes, crunch them. + var vi = vs.and((short)0xff) // lower byte + .mul((short)31) + .add(vs.lanewise(VectorOperators.LSHR, 8)) // upper byte + .reinterpretAsInts(); + // Each int contains 2 shorts, crunch them. + var v = vi.and(0xffff) // lower short + .mul(31 * 31) + .add(vi.lanewise(VectorOperators.LSHR, 16)); // upper short + // Add the correction for the 128 additions above. + v = v.add(-128 * (31*31*31 + 31*31 + 31 + 1)); + // Every element of v now contains a crunched int-package of 4 bytes. + result *= next; + vresult = vresult.mul(next).add(v); + } + result += vresult.mul(vcoef).reduceLanes(VectorOperators.ADD); + for (; i < a.length; i++) { + result = 31 * result + a[i]; + } + return result; + } + } + + public static Object scanAddI_loop(int[] a, int[] r) { + int sum = 0; + for (int i = 0; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static Object scanAddI_loop_reassociate(int[] a, int[] r) { + int sum = 0; + int i = 0; + for (; i < a.length - 3; i += 4) { + // We cut the latency by a factor of 4, but increase the number of additions. + int old_sum = sum; + int v0 = a[i + 0]; + int v1 = a[i + 1]; + int v2 = a[i + 2]; + int v3 = a[i + 3]; + int v01 = v0 + v1; + int v23 = v2 + v3; + int v0123 = v01 + v23; + sum += v0123; + r[i + 0] = old_sum + v0; + r[i + 1] = old_sum + v01; + r[i + 2] = old_sum + v01 + v2; + r[i + 3] = old_sum + v0123; + } + for (; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static Object scanAddI_VectorAPI_permute_add(int[] a, int[] r) { + // Using Naive Parallel Algorithm: Hills and Steele + int sum = 0; + int xx = 0; // masked later anyway + var shf1 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 0); + var shf2 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 0); + var shf3 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, xx, xx, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 0); + var shf4 = VectorShuffle.fromArray(SPECIES_I512, new int[]{xx, xx, xx, xx, xx, xx, xx, xx, 0, 1, 2, 3, 4, 5, 6, 7}, 0); + var mask1 = VectorMask.fromLong(SPECIES_I512, 0b1111111111111110); + var mask2 = VectorMask.fromLong(SPECIES_I512, 0b1111111111111100); + var mask3 = VectorMask.fromLong(SPECIES_I512, 0b1111111111110000); + var mask4 = VectorMask.fromLong(SPECIES_I512, 0b1111111100000000); + int i = 0; + for (; i < SPECIES_I512.loopBound(a.length); i += SPECIES_I512.length()) { + IntVector v = IntVector.fromArray(SPECIES_I512, a, i); + v = v.add(v.rearrange(shf1), mask1); + v = v.add(v.rearrange(shf2), mask2); + v = v.add(v.rearrange(shf3), mask3); + v = v.add(v.rearrange(shf4), mask4); + v = v.add(sum); + v.intoArray(r, i); + sum = v.lane(SPECIES_I512.length() - 1); + } + for (; i < a.length; i++) { + sum += a[i]; + r[i] = sum; + } + return r; + } + + public static int findMinIndexI_loop(int[] a) { + int min = a[0]; + int index = 0; + for (int i = 1; i < a.length; i++) { + int ai = a[i]; + if (ai < min) { + min = ai; + index = i; + } + } + return index; + } + + public static int findMinIndexI_VectorAPI(int[] a) { + // Main approach: have partial results in mins and idxs. + var mins = IntVector.broadcast(SPECIES_I, a[0]); + var idxs = IntVector.broadcast(SPECIES_I, 0); + var iota = IntVector.broadcast(SPECIES_I, 0).addIndex(1); + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.LT, mins); + mins = mins.blend(v, mask); + idxs = idxs.blend(iota, mask); + iota = iota.add(SPECIES_I.length()); + } + // Reduce the vectors down + int min = mins.reduceLanes(VectorOperators.MIN); + var not_min_mask = mins.compare(VectorOperators.NE, min); + int index = idxs.blend(a.length, not_min_mask).reduceLanes(VectorOperators.MIN); + // Tail loop + for (; i < a.length; i++) { + int ai = a[i]; + if (ai < min) { + min = ai; + index = i; + } + } + return index; + } + + public static int findI_loop(int[] a, int e) { + for (int i = 0; i < a.length; i++) { + int ai = a[i]; + if (ai == e) { + return i; + } + } + return -1; + } + + public static int findI_VectorAPI(int[] a, int e) { + var es = IntVector.broadcast(SPECIES_I, e); + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.EQ, es); + if (mask.anyTrue()) { + return i + mask.firstTrue(); + } + } + for (; i < a.length; i++) { + int ai = a[i]; + if (ai == e) { + return i; + } + } + return -1; + } + + public static Object reverseI_loop(int[] a, int[] r) { + for (int i = 0; i < a.length; i++) { + r[a.length - i - 1] = a[i]; + } + return r; + } + + private static final VectorShuffle REVERSE_SHUFFLE_I = SPECIES_I.iotaShuffle(SPECIES_I.length()-1, -1, true); + + public static Object reverseI_VectorAPI(int[] a, int[] r) { + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + v = v.rearrange(REVERSE_SHUFFLE_I); + v.intoArray(r, r.length - SPECIES_I.length() - i); + } + for (; i < a.length; i++) { + r[a.length - i - 1] = a[i]; + } + return r; + } + + public static Object filterI_loop(int[] a, int[] r, int threshold) { + int j = 0; + for (int i = 0; i < a.length; i++) { + int ai = a[i]; + if (ai >= threshold) { + r[j++] = ai; + } + } + // Just force the resulting length onto the same array. + r[r.length - 1] = j; + return r; + } + + public static Object filterI_VectorAPI(int[] a, int[] r, int threshold) { + var thresholds = IntVector.broadcast(SPECIES_I, threshold); + int j = 0; + int i = 0; + for (; i < SPECIES_I.loopBound(a.length); i += SPECIES_I.length()) { + IntVector v = IntVector.fromArray(SPECIES_I, a, i); + var mask = v.compare(VectorOperators.GE, thresholds); + v = v.compress(mask); + int trueCount = mask.trueCount(); + var prefixMask = mask.compress(); + v.intoArray(r, j, prefixMask); + j += trueCount; + } + + for (; i < a.length; i++) { + int ai = a[i]; + if (ai >= threshold) { + r[j++] = ai; + } + } + // Just force the resulting length onto the same array. + r[r.length - 1] = j; + return r; + } + + // X4: ints simulate 4-byte oops. + // oops: if non-zero (= non-null), every entry simulates a 4-byte oop, pointing into mem. + // mem: an int array that simulates the memory. + // + // Task: Find all non-null oops, and dereference them, get the relevant field. + // Objects have 16 bytes, and the relevant field is at bytes 12-16. + // That maps to 4 ints, and the relevant field is the 4th element of 4. + // Sum up all the field values. + public static int reduceAddIFieldsX4_loop(int[] oops, int[] mem) { + int sum = 0; + for (int i = 0; i < oops.length; i++) { + int oop = oops[i]; + if (oop != 0) { + int fieldValue = mem[oop + 3]; // oop+12 + sum += fieldValue; + } + } + return sum; + } + + public static int reduceAddIFieldsX4_VectorAPI(int[] oops, int[] mem) { + var acc = IntVector.broadcast(SPECIES_I, 0); + int i = 0; + for (; i < SPECIES_I.loopBound(oops.length); i += SPECIES_I.length()) { + var oopv = IntVector.fromArray(SPECIES_I, oops, i); + var mask = oopv.compare(VectorOperators.NE, /* null */0); + // We are lucky today: we need to access mem[oop + 3] + var fieldValues = IntVector.fromArray(SPECIES_I, mem, 3, oops, i, mask); + acc = acc.add(fieldValues); + } + int sum = acc.reduceLanes(VectorOperators.ADD); + for (; i < oops.length; i++) { + int oop = oops[i]; + if (oop != 0) { + int fieldValue = mem[oop + 3]; // oop+12 + sum += fieldValue; + } + } + return sum; + } + + // The lowerCase example demonstrates a lane-wise control-flow diamond. + public static Object lowerCaseB_loop(byte[] a, byte[] r) { + for (int i = 0; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); // c += 32 + } + r[i] = c; + } + return r; + } + + // Control-flow diamonds can easily be simulated by "if-conversion", i.e. + // by using masked operations. An alternative would be to use blend. + public static Object lowerCaseB_VectorAPI_v1(byte[] a, byte[] r) { + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vc = ByteVector.fromArray(SPECIES_B, a, i); + var maskA = vc.compare(VectorOperators.GE, (byte)'A'); + var maskZ = vc.compare(VectorOperators.LE, (byte)'Z'); + var mask = maskA.and(maskZ); + vc = vc.add((byte)32, mask); + vc.intoArray(r, i); + } + for (; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); + } + r[i] = c; + } + return r; + } + + public static Object lowerCaseB_VectorAPI_v2(byte[] a, byte[] r) { + int i; + for (i = 0; i < SPECIES_B.loopBound(a.length); i += SPECIES_B.length()) { + var vc = ByteVector.fromArray(SPECIES_B, a, i); + // We can convert the range 65..90 (represents ascii A..Z) into a range 0..25. + // This allows us to only use a single unsigned comparison. + var vt = vc.add((byte)-'A'); + var mask = vt.compare(VectorOperators.ULE, (byte)25); + vc = vc.add((byte)32, mask); + vc.intoArray(r, i); + } + for (; i < a.length; i++) { + byte c = a[i]; + if (c >= 'A' && c <= 'Z') { + c += ('a' - 'A'); + } + r[i] = c; + } + return r; + } +} + From 92072a93bfeb83186df15032d425ed984d24fc52 Mon Sep 17 00:00:00 2001 From: Stefan Karlsson Date: Thu, 29 Jan 2026 08:39:32 +0000 Subject: [PATCH 103/105] 8375747: ZGC: ZForwardingTest is unable to commit memory on Windows Reviewed-by: jsikstro, eosterlund --- src/hotspot/share/gc/z/zAddress.inline.hpp | 8 ++-- test/hotspot/gtest/gc/z/test_zForwarding.cpp | 29 ++++++++---- test/hotspot/gtest/gc/z/zunittest.hpp | 49 ++++++++++++++++++++ 3 files changed, 73 insertions(+), 13 deletions(-) diff --git a/src/hotspot/share/gc/z/zAddress.inline.hpp b/src/hotspot/share/gc/z/zAddress.inline.hpp index c8c8ec7ae3a..0b99802729b 100644 --- a/src/hotspot/share/gc/z/zAddress.inline.hpp +++ b/src/hotspot/share/gc/z/zAddress.inline.hpp @@ -199,18 +199,18 @@ CREATE_ZOFFSET_OPERATORS(zoffset) inline uintptr_t untype(zbacking_offset offset) { const uintptr_t value = static_cast(offset); - assert(value < ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZAddressOffsetMax); + assert(value < ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZBackingOffsetMax); return value; } inline uintptr_t untype(zbacking_offset_end offset) { const uintptr_t value = static_cast(offset); - assert(value <= ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZAddressOffsetMax); + assert(value <= ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZBackingOffsetMax); return value; } inline zbacking_offset to_zbacking_offset(uintptr_t value) { - assert(value < ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZAddressOffsetMax); + assert(value < ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZBackingOffsetMax); return zbacking_offset(value); } @@ -227,7 +227,7 @@ inline zbacking_offset_end to_zbacking_offset_end(zbacking_offset start, size_t } inline zbacking_offset_end to_zbacking_offset_end(uintptr_t value) { - assert(value <= ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZAddressOffsetMax); + assert(value <= ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZBackingOffsetMax); return zbacking_offset_end(value); } diff --git a/test/hotspot/gtest/gc/z/test_zForwarding.cpp b/test/hotspot/gtest/gc/z/test_zForwarding.cpp index 5275b78fb82..6b66d43ae7f 100644 --- a/test/hotspot/gtest/gc/z/test_zForwarding.cpp +++ b/test/hotspot/gtest/gc/z/test_zForwarding.cpp @@ -44,11 +44,12 @@ using namespace testing; class ZForwardingTest : public ZTest { public: // Setup and tear down - ZHeap* _old_heap; - ZGenerationOld* _old_old; - ZGenerationYoung* _old_young; - ZAddressReserver _zaddress_reserver; - zoffset _page_offset; + ZHeap* _old_heap; + ZGenerationOld* _old_old; + ZGenerationYoung* _old_young; + ZAddressReserver _zaddress_reserver; + ZPhysicalMemoryBackingMocker _physical_backing; + zoffset _page_offset; virtual void SetUp() { _old_heap = ZHeap::_heap; @@ -73,8 +74,16 @@ public: GTEST_SKIP() << "Unable to reserve memory"; } - char* const addr = (char*)untype(ZOffset::address_unsafe(_page_offset)); - os::commit_memory(addr, ZGranuleSize, /* executable */ false); + // Setup backing storage + _physical_backing.SetUp(ZGranuleSize); + + size_t committed = _physical_backing()->commit(zbacking_offset(0), ZGranuleSize, 0); + + if (committed != ZGranuleSize) { + GTEST_SKIP() << "Unable to commit memory"; + } + + _physical_backing()->map(ZOffset::address_unsafe(_page_offset), ZGranuleSize, zbacking_offset(0)); } virtual void TearDown() { @@ -84,10 +93,12 @@ public: ZGeneration::_young = _old_young; if (_page_offset != zoffset::invalid) { - char* const addr = (char*)untype(ZOffset::address_unsafe(_page_offset)); - os::uncommit_memory(addr, ZGranuleSize, false /* executable */); + _physical_backing()->unmap(ZOffset::address_unsafe(_page_offset), ZGranuleSize); + _physical_backing()->uncommit(zbacking_offset(0), ZGranuleSize); } + _physical_backing.TearDown(); + _zaddress_reserver.TearDown(); } diff --git a/test/hotspot/gtest/gc/z/zunittest.hpp b/test/hotspot/gtest/gc/z/zunittest.hpp index 2464f821380..13a8eb10f8a 100644 --- a/test/hotspot/gtest/gc/z/zunittest.hpp +++ b/test/hotspot/gtest/gc/z/zunittest.hpp @@ -28,6 +28,7 @@ #include "gc/z/zArguments.hpp" #include "gc/z/zInitialize.hpp" #include "gc/z/zNUMA.hpp" +#include "gc/z/zPhysicalMemoryManager.hpp" #include "gc/z/zRangeRegistry.hpp" #include "gc/z/zVirtualMemory.inline.hpp" #include "gc/z/zVirtualMemoryManager.hpp" @@ -104,6 +105,54 @@ public: } }; + class ZPhysicalMemoryBackingMocker { + size_t _old_max; + ZPhysicalMemoryBacking* _backing; + bool _active; + + static size_t set_max(size_t max_capacity) { + size_t old_max = ZBackingOffsetMax; + + ZBackingOffsetMax = max_capacity; + ZBackingIndexMax = checked_cast(ZBackingOffsetMax >> ZGranuleSizeShift); + + return old_max; + } + + public: + ZPhysicalMemoryBackingMocker() + : _old_max(0), + _backing(nullptr), + _active(false) {} + + void SetUp(size_t max_capacity) { + GTEST_EXPECT_FALSE(_active) << "SetUp called twice without a TearDown"; + + _old_max = set_max(max_capacity); + + char* const mem = (char*)os::malloc(sizeof(ZPhysicalMemoryBacking), mtTest); + _backing = new (mem) ZPhysicalMemoryBacking(ZGranuleSize); + + _active = true; + } + + void TearDown() { + GTEST_EXPECT_TRUE(_active) << "TearDown called without a preceding SetUp"; + + _active = false; + + _backing->~ZPhysicalMemoryBacking(); + os::free(_backing); + _backing = nullptr; + + set_max(_old_max); + } + + ZPhysicalMemoryBacking* operator()() { + return _backing; + } + }; + private: ZAddressOffsetMaxSetter _zaddress_offset_max_setter; unsigned int _rand_seed; From f9cc104249433eec179c98cb3fb44546254bf588 Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Thu, 29 Jan 2026 08:54:37 +0000 Subject: [PATCH 104/105] 8376335: Convert PreservedMarks classes to use Atomic Reviewed-by: stefank, iwalulya --- .../share/gc/shared/preservedMarks.cpp | 30 +++++++++---------- .../share/gc/shared/preservedMarks.hpp | 7 ++--- 2 files changed, 16 insertions(+), 21 deletions(-) diff --git a/src/hotspot/share/gc/shared/preservedMarks.cpp b/src/hotspot/share/gc/shared/preservedMarks.cpp index 1c9f1c82e6f..605b7afe072 100644 --- a/src/hotspot/share/gc/shared/preservedMarks.cpp +++ b/src/hotspot/share/gc/shared/preservedMarks.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -29,7 +29,7 @@ #include "memory/allocation.inline.hpp" #include "memory/resourceArea.hpp" #include "oops/oop.inline.hpp" -#include "runtime/atomicAccess.hpp" +#include "runtime/atomic.hpp" #include "utilities/macros.hpp" void PreservedMarks::restore() { @@ -55,15 +55,6 @@ void PreservedMarks::adjust_during_full_gc() { } } -void PreservedMarks::restore_and_increment(volatile size_t* const total_size_addr) { - const size_t stack_size = size(); - restore(); - // Only do the atomic add if the size is > 0. - if (stack_size > 0) { - AtomicAccess::add(total_size_addr, stack_size); - } -} - #ifndef PRODUCT void PreservedMarks::assert_empty() { assert(_stack.is_empty(), "stack expected to be empty, size = %zu", @@ -93,7 +84,7 @@ void PreservedMarksSet::init(uint num) { class RestorePreservedMarksTask : public WorkerTask { PreservedMarksSet* const _preserved_marks_set; SequentialSubTasksDone _sub_tasks; - volatile size_t _total_size; + Atomic _total_size; #ifdef ASSERT size_t _total_size_before; #endif // ASSERT @@ -102,7 +93,12 @@ public: void work(uint worker_id) override { uint task_id = 0; while (_sub_tasks.try_claim_task(task_id)) { - _preserved_marks_set->get(task_id)->restore_and_increment(&_total_size); + PreservedMarks* next = _preserved_marks_set->get(task_id); + size_t num_restored = next->size(); + next->restore(); + if (num_restored > 0) { + _total_size.add_then_fetch(num_restored); + } } } @@ -121,9 +117,11 @@ public: } ~RestorePreservedMarksTask() { - assert(_total_size == _total_size_before, "total_size = %zu before = %zu", _total_size, _total_size_before); - size_t mem_size = _total_size * (sizeof(oop) + sizeof(markWord)); - log_trace(gc)("Restored %zu marks, occupying %zu %s", _total_size, + size_t local_total_size = _total_size.load_relaxed(); + + assert(local_total_size == _total_size_before, "total_size = %zu before = %zu", local_total_size, _total_size_before); + size_t mem_size = local_total_size * (sizeof(oop) + sizeof(markWord)); + log_trace(gc)("Restored %zu marks, occupying %zu %s", local_total_size, byte_size_in_proper_unit(mem_size), proper_unit_for_byte_size(mem_size)); } diff --git a/src/hotspot/share/gc/shared/preservedMarks.hpp b/src/hotspot/share/gc/shared/preservedMarks.hpp index 10f75116524..3bbbd335011 100644 --- a/src/hotspot/share/gc/shared/preservedMarks.hpp +++ b/src/hotspot/share/gc/shared/preservedMarks.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, 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 @@ -59,8 +59,7 @@ public: size_t size() const { return _stack.size(); } inline void push_if_necessary(oop obj, markWord m); inline void push_always(oop obj, markWord m); - // Iterate over the stack, restore all preserved marks, and - // reclaim the memory taken up by the stack segments. + // Restore all preserved marks, and reclaim the memory taken up by the stack segments. void restore(); // Adjust the preserved mark according to its @@ -71,8 +70,6 @@ public: // to their forwarding location stored in the mark. void adjust_during_full_gc(); - void restore_and_increment(volatile size_t* const _total_size_addr); - // Assert the stack is empty and has no cached segments. void assert_empty() PRODUCT_RETURN; From 681e4ec8d37f4e30462b43e1c789d53525211b0a Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Thu, 29 Jan 2026 08:54:59 +0000 Subject: [PATCH 105/105] 8376350: Convert ReferenceProcessorPhaseTimes to use Atomic Reviewed-by: stefank, iwalulya --- .../share/gc/shared/referenceProcessorPhaseTimes.cpp | 9 ++++----- .../share/gc/shared/referenceProcessorPhaseTimes.hpp | 5 +++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp index df7d8f7b38d..0371ed2c73b 100644 --- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp +++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -30,7 +30,6 @@ #include "logging/logStream.hpp" #include "memory/allocation.inline.hpp" #include "memory/resourceArea.hpp" -#include "runtime/atomicAccess.hpp" #define ASSERT_REF_TYPE(ref_type) assert((ref_type) >= REF_SOFT && (ref_type) <= REF_PHANTOM, \ "Invariant (%d)", (int)ref_type) @@ -196,7 +195,7 @@ void ReferenceProcessorPhaseTimes::reset() { _soft_weak_final_refs_phase_worker_time_sec->reset(); for (int i = 0; i < number_of_subclasses_of_ref; i++) { - _ref_dropped[i] = 0; + _ref_dropped[i].store_relaxed(0); _ref_discovered[i] = 0; } @@ -214,7 +213,7 @@ ReferenceProcessorPhaseTimes::~ReferenceProcessorPhaseTimes() { void ReferenceProcessorPhaseTimes::add_ref_dropped(ReferenceType ref_type, size_t count) { ASSERT_REF_TYPE(ref_type); - AtomicAccess::add(&_ref_dropped[ref_type_2_index(ref_type)], count, memory_order_relaxed); + _ref_dropped[ref_type_2_index(ref_type)].add_then_fetch(count, memory_order_relaxed); } void ReferenceProcessorPhaseTimes::set_ref_discovered(ReferenceType ref_type, size_t count) { @@ -271,7 +270,7 @@ void ReferenceProcessorPhaseTimes::print_reference(ReferenceType ref_type, uint int const ref_type_index = ref_type_2_index(ref_type); size_t discovered = _ref_discovered[ref_type_index]; - size_t dropped = _ref_dropped[ref_type_index]; + size_t dropped = _ref_dropped[ref_type_index].load_relaxed(); assert(discovered >= dropped, "invariant"); size_t processed = discovered - dropped; diff --git a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp index 16691452ef4..82d26902bce 100644 --- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp +++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, 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 @@ -30,6 +30,7 @@ #include "gc/shared/workerDataArray.hpp" #include "memory/allocation.hpp" #include "memory/referenceType.hpp" +#include "runtime/atomic.hpp" #include "utilities/ticks.hpp" class DiscoveredList; @@ -52,7 +53,7 @@ class ReferenceProcessorPhaseTimes : public CHeapObj { // Total spent time for reference processing. double _total_time_ms; - size_t _ref_dropped[number_of_subclasses_of_ref]; + Atomic _ref_dropped[number_of_subclasses_of_ref]; size_t _ref_discovered[number_of_subclasses_of_ref]; bool _processing_is_mt;