JT Harness : Tests that passed

Tests are grouped by their final status message.

Clean successful

compiler/jvmci/compilerToVM/GetLocalVariableTableTest.java:

Execution successful

compiler/allocation/TestAllocArrayAfterAllocNoUse.java: fatal error: no reachable node should have no use
compiler/allocation/TestAllocation.java: Testing allocation expansion when there is no use of the allocation
compiler/allocation/TestCCPAllocateArray.java: C2: assert(t->meet(t0) == t) failed: Not monotonic after JDK-8278413
compiler/allocation/TestFailedAllocationBadGraph.java: C2 crash when allocating array of size too large
compiler/allocation/TestNewArrayBadSize.java: C2 compilation asserts with "Bad graph detected in compute_lca_of_uses"
compiler/allocation/TestNewArrayOutsideLoopValidLengthTestInLoop.java: C2: assert compiling SSLEngineInputRecord::decodeInputRecord
compiler/allocation/TestNewMaxLengthArray.java: C2: large byte array clone triggers "failed: malformed control flow" assertion failure on linux-x86
compiler/arguments/CheckCICompilerCount.java: Check that correct range of values for CICompilerCount are allowed depending on whether tiered is enabled or not
compiler/arguments/CheckCompileThresholdScaling.java: Add CompileThresholdScaling flag to control when methods are first compiled (with +/-TieredCompilation)
compiler/arguments/TestScavengeRootsInCode.java: Test compilation with non-default value for ScavengeRootsInCode.
compiler/arguments/TestStressReflectiveCode.java: Test running with StressReflectiveCode enabled.
compiler/arguments/TestTraceICs.java: Test running TraceICs enabled.
compiler/arguments/TestUseBMI1InstructionsOnSupportedCPU.java: Verify processing of UseBMI1Instructions option on CPU with BMI1 feature support.
compiler/arguments/TestUseBMI1InstructionsOnUnsupportedCPU.java: Verify processing of UseBMI1Instructions option on CPU without BMI1 feature support.
compiler/arguments/TestUseCompiler.java: Tests execution with inconsistent UseCompiler flag combination.
compiler/arguments/TestUseCountLeadingZerosInstructionOnSupportedCPU.java: Verify processing of UseCountLeadingZerosInstruction option on CPU with LZCNT support.
compiler/arguments/TestUseCountLeadingZerosInstructionOnUnsupportedCPU.java: Verify processing of UseCountLeadingZerosInstruction option on CPU without LZCNT support.
compiler/arguments/TestUseCountTrailingZerosInstructionOnSupportedCPU.java: Verify processing of UseCountTrailingZerosInstruction option on CPU with TZCNT (BMI1 feature) support.
compiler/arguments/TestUseCountTrailingZerosInstructionOnUnsupportedCPU.java: Verify processing of UseCountTrailingZerosInstruction option on CPU without TZCNT instruction (BMI1 feature) support.
compiler/arraycopy/ACasLoadsStoresBadMem.java: arraycopy converted as a series of loads/stores uses wrong slice for loads
compiler/arraycopy/TestACSameSrcDst.java: ArrayCopy with same src and dst can cause incorrect execution or compiler crash
compiler/arraycopy/TestArrayCloneBadAssert.java: assert broken when array size becomes known during igvn
compiler/arraycopy/TestArrayCopyAsLoadsStores.java#id0: small array copy as loads/stores
compiler/arraycopy/TestArrayCopyAsLoadsStores.java#id1:
compiler/arraycopy/TestArrayCopyBadReexec.java: Fix for 8064703 may also cause stores between the allocation and arraycopy to be rexecuted after a deoptimization
compiler/arraycopy/TestArrayCopyConjoint.java: Optimize arrayCopy using AVX-512 masked instructions.
compiler/arraycopy/TestArrayCopyDisjoint.java: Optimize arrayCopy using AVX-512 masked instructions.
compiler/arraycopy/TestArrayCopyDisjointLarge.java: Test large arrayCopy.
compiler/arraycopy/TestArrayCopyIntrinsicWithUCT.java: Test taking UCT between array allocation and array copy to report correct exception.
compiler/arraycopy/TestArrayCopyMacro.java: arraycopy as macro node
compiler/arraycopy/TestArrayCopyMaskedWithZeroSrc.java: Test that LoadVectorMaskedNodes works when the source array is known to only contain zeros
compiler/arraycopy/TestArrayCopyMemoryChain.java: Test correct wiring of load/store memory for arraycopy ideal transformation.
compiler/arraycopy/TestArrayCopyNoInit.java: Deoptimization between array allocation and arraycopy may result in non initialized array
compiler/arraycopy/TestArrayCopyNoInitDeopt.java: Infinite deoptimization/recompilation cycles in case of arraycopy with tightly coupled allocation
compiler/arraycopy/TestArrayCopyOfStopped.java: after guards in Arrays.copyOf() intrinsic, control may become top
compiler/arraycopy/TestArrayCopyOverflowArguments.java: Test that overflowed integers passed to arraycopy don't do any harm.
compiler/arraycopy/TestArrayCopyOverflowInBoundChecks.java: test that checks whether an array load falls into the range of an arraycopy is incorrect on 32bits
compiler/arraycopy/TestArrayCopyPartialInliningLoadSplit.java: misc tests failed "assert(false) failed: graph should be schedulable"
compiler/arraycopy/TestArrayCopyStoppedAfterGuards.java: control becomes top after arraycopy guards and confuses tighly coupled allocation logic
compiler/arraycopy/TestArrayCopyUNCBadMem.java: Loads generated at uncommon trap from eliminated arraycopy have incorrect memory state
compiler/arraycopy/TestArrayCopyWithBadOffset.java: Test arraycopy optimizations with bad src/dst array offsets.
compiler/arraycopy/TestArraysCopyOfNoTypeCheck.java: Arrays.copyOf doesn't perform subtype check
compiler/arraycopy/TestCloneAccess.java: Test cloning with more than 8 (=ArrayCopyLoadStoreMaxElem) where loads are wrongly replaced by zero.
compiler/arraycopy/TestDeadArrayCopyOnMemChain.java: eliminated arraycopy node still reachable through exception edges
compiler/arraycopy/TestDefaultMethodArrayCloneDeoptC2.java: C2: Access to [].clone from interfaces fails.
compiler/arraycopy/TestEliminateArrayCopy.java: arraycopy to non escaping destination may be eliminated
compiler/arraycopy/TestEliminatedArrayCopyDeopt.java: Eliminated instance/array written to by an array copy variant must be correctly initialized when reallocated at a deopt
compiler/arraycopy/TestEliminatedArrayCopyPhi.java: Code that capture field values of eliminated allocation at a safepoint when there's an arraycopy behind a Phi is broken
compiler/arraycopy/TestEliminatedArrayLoopPredicateCopyDeopt.java: Cannot pin eliminated arraycopy loads for deopt state in uncommon trap path if it is a loop predicate unc
compiler/arraycopy/TestEliminatedCloneBadMemEdge.java: Elimination of clone's ArrayCopyNode may make compilation fail silently
compiler/arraycopy/TestIllegalArrayCopyBeforeInfiniteLoop.java: ArrayCopy with negative index before infinite loop
compiler/arraycopy/TestInstanceCloneAsLoadsStores.java: small instance clone as loads/stores
compiler/arraycopy/TestLoadBypassArrayCopy.java: load bypasses arraycopy that sets the value after the ArrayCopyNode is expanded
compiler/arraycopy/TestMissingControl.java: missing control on LoadRange and LoadKlass when array copy macro node is expanded
compiler/arraycopy/TestNegativeArrayCopyAfterLoop.java: C2 inline array_copy move CastIINode(Array Length) before allocation cause crash.
compiler/arraycopy/TestObjectArrayClone.java: Test Object.clone() intrinsic.
compiler/arraycopy/TestObjectArrayCopy.java: Wrong assertion 'should be an array copy/clone' in arraycopynode.cpp
compiler/arraycopy/TestOutOfBoundsArrayLoad.java: Out of bounds array load on clone source crashes GC which interpretes the loaded value as oop.
compiler/arraycopy/TestReduceBulkZeroingDisabled.java: Test arraycopy elimination with ReduceBulkZeroing disabled.
compiler/arraycopy/TestTightlyCoupledAllocationAssert.java: Test that triggers the too strong assertion "just_allocated_object(alloc_ctl) == ptr" in LibraryCallKit::tightly_coupled_allocation()
compiler/blackhole/BlackholeExistingIntrinsicWarningTest.java:
compiler/blackhole/BlackholeExperimentalUnlockTest.java:
compiler/blackhole/BlackholeIntrinsicTest.java:
compiler/blackhole/BlackholeNonEmptyWarningTest.java:
compiler/blackhole/BlackholeNonStaticWarningTest.java:
compiler/blackhole/BlackholeNonVoidWarningTest.java:
compiler/c1/ArithmeticRemRCE.java: apply RCE for % operations
compiler/c1/CCEMessageTest.java: C1 dumps incorrect class name in CCE message
compiler/c1/CanonicalizeArrayLength.java: C1 crashes in Canonicalizer::do_ArrayLength() after fix for JDK-8150102
compiler/c1/CanonicalizeGetModifiers.java#id0: Canonicalizes Foo.class.getModifiers() with interpreter mode
compiler/c1/CanonicalizeGetModifiers.java#id1: Canonicalizes Foo.class.getModifiers() with C1 mode
compiler/c1/CanonicalizeGetModifiers.java#id2: Canonicalizes Foo.class.getModifiers() with C2 mode
compiler/c1/KlassAccessCheckTest.java:
compiler/c1/MultiplyByMaxInt.java:
compiler/c1/NullCheckTest.java: C1 NullCheckEliminator yields incorrect exceptions
compiler/c1/RangeCheckVerificationOfIR.java: Checks the C1 RangeCheckEliminator::Verification code for nested exceptions in loops that are always executed once on the non-exceptional path.
compiler/c1/Test6579789.java: Internal error "c1_LinearScan.cpp:1429 Error: assert(false,"")" in debuggee with fastdebug VM
compiler/c1/Test6756768.java: C1 generates invalid code
compiler/c1/Test6756768_2.java: C1 generates invalid code
compiler/c1/Test6757316.java: load_constant() produces a wrong long constant, with high a low words swapped
compiler/c1/Test6758234.java: if (k cond (a ? : b: c)) returns reversed answer if k is constant and b and c are longs
compiler/c1/Test6795465.java: Crash in assembler_sparc.cpp with client compiler on solaris-sparc
compiler/c1/Test6849574.java: VM crash using NonBlockingHashMap (high_scale_lib)
compiler/c1/Test6855215.java: Calculation error (NaN) after about 1500 calculations
compiler/c1/Test6932496.java: incorrect deopt of jsr subroutine on 64 bit c1
compiler/c1/Test7042153.java: Bad folding of IfOps with unloaded constant arguments in C1
compiler/c1/Test7090976.java: Eclipse/CDT causes a JVM crash while indexing C++ code
compiler/c1/Test7103261.java: crash with jittester on sparc
compiler/c1/Test7123108.java: C1 crashes with assert(if_state != NULL) failed: states do not match up
compiler/c1/Test8004051.java: assert(_oprs_len[mode] < maxNumberOfOperands) failed: array overflow
compiler/c1/Test8011706.java: loop invariant code motion may move load before store to the same field
compiler/c1/Test8011771.java: Array bound check elimination's in block motion doesn't always reset its data structures from one step to the other.
compiler/c1/Test8172751.java: OSR compilation at unreachable bci causes C1 crash
compiler/c1/Test8211100.java: hotspot C1 issue with comparing long numbers on x86 32-bit
compiler/c1/Test8267042.java: missing displaced_header initialization causes hangup
compiler/c1/Test8275337.java:
compiler/c1/Test8301489.java: ShortLoopOptimizer might lift instructions before their inputs
compiler/c1/TestArrayCopy.java: arraycopy may crash the VM with c1 on 64 bit
compiler/c1/TestArrayCopyToFromObject.java: C1-generated code for System.arraycopy() does not throw an ArrayStoreException if 'dst' is no a "proper" array (i.e., it is java.lang.Object)
compiler/c1/TestBadStateAtLongCmp.java: Incorrect result when switching to C2 OSR compilation from C1
compiler/c1/TestC1PhiPlacementPathologyMain.java: Test a pathological case for phi placement with an irreducible loop of a particular shape.
compiler/c1/TestDeoptInt.java: int value might not be correctly decoded on deopt with c1 on 64 bit
compiler/c1/TestGotoIfMain.java:
compiler/c1/TestInvokeinterfaceWithBadReceiver.java: Test monomorphic interface call to with invalid receiver.
compiler/c1/TestLargeMonitorOffset.java: Verify that monitors with large offset in the OSR buffer are handled properly.
compiler/c1/TestLinearScanHasFPURegisters.java:
compiler/c1/TestLinearScanOrderMain.java:
compiler/c1/TestLoadIndexedMismatch.java: C1: Incorrect LoadIndexed value numbering
compiler/c1/TestManyMethodParameters.java: Test if a call with 8 integer + 13 float = 21 parameters can can be compiled.
compiler/c1/TestOSRLotsOfLocals.java: Test that OSR correctly handles method with large number of locals
compiler/c1/TestPinnedConstantExceptionEdge.java: Add check in LinearScan::resolve_exception_edge for pinned constant that is not virtual which cannot be used to find an interval which resulted in an assertion error.
compiler/c1/TestPinnedIntrinsics.java: Test correct scheduling of System.nanoTime C1 intrinsic.
compiler/c1/TestStaticInterfaceMethodCall.java: Test invocation of static interface method with and without method handle with C1.
compiler/c1/TestTooManyVirtualRegistersMain.java: Tests custom bytecode which requires too many virtual registers in the linear scan of C1.
compiler/c1/TestUnalignedLoad.java: unaligned load may fail with c1 on 64 bit
compiler/c1/TestUnresolvedFieldMain.java:
compiler/c1/TestValueNumberingNullObject.java: CTW: C1 compilation fails with assert(x->type()->tag() == f->type()->tag()) failed: should have same type
compiler/c1/UnsafeVolatileGuardTest.java: C1 value numbering handling of Unsafe.get*Volatile is incorrect
compiler/c1/VolatileGuardTest.java: C1 doesn't respect the JMM with volatile field loads
compiler/c2/ClearArray.java: ClearArray instruction overflows scratch buffer
compiler/c2/CompareKlassPointersTest.java: This test uses a class pointer comparison optimization which was not applied anymore since JDK-6964458 resulting in a better IR.
compiler/c2/FloatingPointFoldingTest.java: Test that causes C2 to fold two NaNs with different values into a single NaN.
compiler/c2/IVTest.java: JVM crashes while trying to execute api/java_security/Signature/SignatureTests.html#initSign tests.
compiler/c2/InterruptedTest.java: Thread.isInterrupted() fails to return true on multiprocessor PC
compiler/c2/IsInstanceTest.java: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
compiler/c2/LongCountedLoopAsUnswitchIff.java: C2: assert(iff->Opcode() == Op_If || iff->Opcode() == Op_CountedLoopEnd || iff->Opcode() == Op_RangeCheck) failed: Check this code when new subtype is added
compiler/c2/PolynomialRoot.java: C2: assert(!def_outside->member(r)) failed: Use of external LRG overlaps the same LRG defined in this block
compiler/c2/SubsumingLoadsCauseFlagSpill.java: assert failure in coalesce.cpp: attempted to spill a non-spillable item
compiler/c2/Test5057225.java: Remove useless I2L conversions
compiler/c2/Test5091921.java: Sign flip issues in loop optimizer
compiler/c2/Test6186134.java: Server virtual machine produces/exeutes incorrect code.
compiler/c2/Test6196102.java: Integer seems to be greater than Integer.MAX_VALUE
compiler/c2/Test6357214.java: Hotspot server compiler gets integer comparison wrong
compiler/c2/Test6443505.java: Some cases for CmpLTMask missed; also wrong code.
compiler/c2/Test6559156.java: Server compiler generates bad code for "<= Integer.MAX_VALUE" expression
compiler/c2/Test6636138_1.java: SuperWord::co_locate_pack(Node_List* p) generates memory graph that leads to memory order violation.
compiler/c2/Test6636138_2.java: SuperWord::co_locate_pack(Node_List* p) generates memory graph that leads to memory order violation.
compiler/c2/Test6646019.java: array subscript expressions become top() with -d64
compiler/c2/Test6661247.java: Internal bug in 32-bit HotSpot optimizer while bit manipulations
compiler/c2/Test6695810.java: null oop passed to encode_heap_oop_not_null
compiler/c2/Test6700047.java: C2 failed in idom_no_update
compiler/c2/Test6711100.java: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
compiler/c2/Test6724218.java: Fix raise_LCA_above_marks() early termination
compiler/c2/Test6732154.java: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
compiler/c2/Test6741738.java: TypePtr::add_offset() set incorrect offset when the add overflows
compiler/c2/Test6753639.java: Strange optimisation in for loop with cyclic integer condition
compiler/c2/Test6795362.java: 32bit server compiler leads to wrong results on solaris-x86
compiler/c2/Test6796786.java: invalid FP identity transform - (a - b) -> b - a
compiler/c2/Test6799693.java: Server compiler leads to data corruption when expression throws an Exception
compiler/c2/Test6800154.java: Add comments to long_by_long_mulhi() for better understandability
compiler/c2/Test6805724.java: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
compiler/c2/Test6823453.java: DeoptimizeALot causes fastdebug server jvm to fail with assert(false,"unscheduable graph")
compiler/c2/Test6832293.java: JIT compiler got wrong result in type checking with -server
compiler/c2/Test6837011.java: SIGSEGV in PhaseIdealLoop in 32bit jvm
compiler/c2/Test6837094.java: False positive for "meet not symmetric" failure
compiler/c2/Test6843752.java: missing code for an anti-dependent Phi in GCM
compiler/c2/Test6851282.java: JIT miscompilation results in null entry in array when using CompressedOops
compiler/c2/Test6857159.java: local schedule failed with checkcast of Thread.currentThread()
compiler/c2/Test6863155.java: Server compiler generates incorrect code (x86, long, bitshift, bitmask)
compiler/c2/Test6866651.java: delay dead node elimination in set_req_X to prevent killing the current node when it is in use
compiler/c2/Test6877254.java: Implement StoreCMNode::Ideal to promote its OopStore above the MergeMem
compiler/c2/Test6880034.java: SIGBUS during deoptimisation at a safepoint on 64bit-SPARC
compiler/c2/Test6885584.java: A particular class structure causes large allocation spike for jit
compiler/c2/Test6897150.java: Hotspot optimises away a valid loop
compiler/c2/Test6901572.java: JVM 1.6.16 crash on loops: assert(has_node(i),"")
compiler/c2/Test6910484.java: incorrect integer optimization (loosing and op-r in a given example)
compiler/c2/Test6910605_1.java: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used original test: nsk/coverage/runtime/runtime007
compiler/c2/Test6910605_2.java: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
compiler/c2/Test6916644.java: C2 compiler crash on x86
compiler/c2/Test6930043.java: C2: SIGSEGV in javasoft.sqe.tests.lang.arr017.arr01702.arr01702.loop_forw(II)I
compiler/c2/Test6931567.java: JIT Error (on class file compiled with eclipse) on JVM x64 (but not on x32!).
compiler/c2/Test6935022.java: Server VM incorrectly breaks out of while loop
compiler/c2/Test6956668.java: misbehavior of XOR operator (^) with int
compiler/c2/Test6958485.java: fix for 6879921 was insufficient
compiler/c2/Test6959129.java: COMPARISON WITH INTEGER.MAX_INT DOES NOT WORK CORRECTLY IN THE CLIENT VM.
compiler/c2/Test6968348.java: Byteswapped memory access can point to wrong location after JIT
compiler/c2/Test6973329.java: C2 with Zero based COOP produces code with broken anti-dependency on x86
compiler/c2/Test6985295.java: JVM fails to evaluate condition randomly
compiler/c2/Test6992759.java: Bad code generated for integer <= comparison, fails for Integer.MAX_VALUE
compiler/c2/Test7002666.java: eclipse CDT projects crash with compressed oops
compiler/c2/Test7005594.java: Array overflow not handled correctly with loop optimzations
compiler/c2/Test7009359.java: HS optimizes new StringBuffer(null) so it does not throw NPE as expected
compiler/c2/Test7017746.java: Regression : C2 compiler crash due to SIGSEGV in PhaseCFG::schedule_early()
compiler/c2/Test7020614.java: "-server" mode optimizer makes code hang
compiler/c2/Test7024475.java: loop doesn't terminate when compiled
compiler/c2/Test7029152.java: Ideal nodes for String intrinsics miss memory edge optimization
compiler/c2/Test7041100.java: The load in String.equals intrinsic executed before null check
compiler/c2/Test7046096.java: SEGV IN C2 WITH 6U25
compiler/c2/Test7047069.java: Array can dynamically change size when assigned to an object field
compiler/c2/Test7048332.java: Cadd_cmpLTMask doesn't handle 64-bit tmp register properly
compiler/c2/Test7068051.java: SIGSEGV in PhaseIdealLoop::build_loop_late_post on T5440
compiler/c2/Test7110586.java: C2 generates icorrect results
compiler/c2/Test7125879.java: assert(proj != NULL) failed: must be found
compiler/c2/Test7160610.java: Unknown Native Code compilation issue.
compiler/c2/Test7169782.java: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
compiler/c2/Test7174363.java: crash with Arrays.copyOfRange(original, from, to) when from > original.length
compiler/c2/Test7177917.java: Micro-benchmark for Math.pow() and Math.exp()
compiler/c2/Test7179138_2.java: Incorrect result with String concatenation optimization
compiler/c2/Test7190310.java: Inlining WeakReference.get(), and hoisting $referent may lead to non-terminating loops
compiler/c2/Test7190310_unsafe.java: Inlining WeakReference.get(), and hoisting $referent may lead to non-terminating loops
compiler/c2/Test7199742.java: A lot of C2 OSR compilations of the same method's bci
compiler/c2/Test8000805.java: JMM issue: short loads are non-atomic
compiler/c2/Test8002069.java: Assert failed in C2: assert(field->edge_count() > 0) failed: sanity
compiler/c2/Test8007294.java: ReduceFieldZeroing doesn't check for dependent load and can lead to incorrect execution
compiler/c2/Test8007722.java: GetAndSetP's MachNode should capture bottom type
compiler/c2/Test8062950.java:
compiler/c2/Test8202414.java: Unsafe write after primitive array creation may result in array length change
compiler/c2/Test8217359.java: C2 compiler triggers SIGSEGV after transformation in ConvI2LNode::Ideal
compiler/c2/Test8bitLogicalOperators.java: Missing x86_64.ad patterns for 8-bit logical operators with destination in memory
compiler/c2/TestAddXorIdeal.java: C2: Improve Add and Xor ideal optimizations
compiler/c2/TestBitSetAndReset.java: Missing x86_64.ad patterns for clearing and setting long vector bits
compiler/c2/TestCMoveHasTopInput.java: C2: assert(false) failed: bad AD file after JDK-8267687
compiler/c2/TestCharShortByteSwap.java: Tests Character/Short.reverseBytes and their intrinsics implementation in the server compiler
compiler/c2/TestCondAddDeadBranch.java: C2: assert(false) failed: unscheduable graph
compiler/c2/TestDeadDataLoop.java: An unreachable loop is not removed, leading to a broken graph.
compiler/c2/TestDeadDataLoopIGVN.java: A dead data loop in dying code is not correctly removed resulting in unremovable data nodes.
compiler/c2/TestDeadPhiMergeMemLoop.java: A dead memory loop is detected when replacing an actually dead memory phi node in PhiNode::Ideal() by a dead MergeMemNode which builds a cycle with one of its slices.
compiler/c2/TestDominatingDeadCheckCast.java: node replaced by dominating dead cast during parsing
compiler/c2/TestFoldCompares.java: C2 crash in IfNode::fold_compares
compiler/c2/TestIfWithDeadRegion.java: Test IfNode::up_one_dom() with dead regions.
compiler/c2/TestImplicitNullCheckDominance.java: Check correct re-wiring of control edge when hoisting a memory operation for an implicit null check.
compiler/c2/TestLiveNodeLimit.java: Test which exceeds the live node limit in Compile::Code_Gen().
compiler/c2/TestMatcherLargeOffset.java: C2: Unexpected dead nodes after matching
compiler/c2/TestModDivTopInput.java: C2: assert(_base == Long) failed: Not a Long
compiler/c2/TestMultiplyLongHiZero.java: Tests shorter long multiply sequences when the high 32 bits of long operands are known to be zero on x86_32
compiler/c2/TestNPEHeapBased.java: Invalid ImplicitNullChecks when heap base not protected
compiler/c2/TestRemoveMemBarPrecEdge.java: Test removal of precedence edge of MemBarAcquire together with other now dead input nodes which visits a top node.
compiler/c2/TestRenumberLiveNodesInfiniteLoop.java: Crash in PhaseIdealLoop::verify_strip_mined_scheduling
compiler/c2/TestReplaceEquivPhis.java: Unexpected test result caused by C2 MergeMemNode::Ideal
compiler/c2/TestReplacedNodesOSR.java: SafePointNode::_replaced_nodes breaks with irreducible loops
compiler/c2/TestRotateNegativeEvenValues.java: Test RotateLeftNode and RotateRightNode with negative even numbers which produces a wrong result due to applying an arithemtic instead of a logical shift.
compiler/c2/TestShiftRightAndAccumulate.java#id0: AArch64: Wrong code generated for shifting right and accumulating four unsigned short integers.
compiler/c2/TestShiftRightAndAccumulate.java#id1: AArch64: Wrong code generated for shifting right and accumulating four unsigned short integers.
compiler/c2/TestSignExtract.java: Better implementation for sign extract.
compiler/c2/TestSkipLongToIntCast.java: Functional test to enshure CmpL(int value, long constant) is not broken
compiler/c2/TestTopCastIIOnUndetectedDeadPath.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath2.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath3.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#JDK-8293941: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#JDK-8314111: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#NoFlags: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestUnalignedAccess.java: AArch64: C2 compilation hits offset_ok_for_immed: assert "c2 compiler bug".
compiler/c2/TestUnreachableRegionDuringCCP.java: Test removal of unreachable regions during CCP.
compiler/c2/TestUnsignedByteCompare.java: Bitwise AND on byte value sometimes produces wrong result
compiler/c2/TestUnsignedByteCompare1.java:
compiler/c2/TestUnsignedCompareIntoEqualityNotCanonical.java: C2: assert(BoolTest(btest).is_canonical()) failure
compiler/c2/TestUseOptoBiasInliningWithoutEliminateLocks.java: With -XX:+UseOptoBiasInlining loading the markword is replaced by 0L if EliminateLocks is disabled.
compiler/c2/UpcastTest.java:
compiler/c2/aarch64/ConvI2LWideningAssertTooStrong.java: C2 OSR compilation fails with "shouldn't process one node several times" in final graph reshaping
compiler/c2/aarch64/TestIntrinsicsRegStress.java: Verify vector register clobbering in some aarch64 intrinsics
compiler/c2/cr6646020/Tester.java: assert(in_bb(n),"must be in block") in -Xcomp mode
compiler/c2/cr6663848/Tester.java: assert(i < Max(),"oob")
compiler/c2/cr6663854/Test6663854.java: assert(n != __null,"Bad immediate dominator info.") in C2 with -Xcomp
compiler/c2/cr6711117/Test.java: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
compiler/c2/cr6712835/Test6712835.java: Server compiler fails with assertion (loop_count < K,"infinite loop in PhaseIterGVN::transform")
compiler/c2/cr6714694/Tester.java: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs
compiler/c2/cr6865031/Test.java: Application gives bad result (throws bad exception) with compressed oops
compiler/c2/cr7192963/TestByteVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestDoubleVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestFloatVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestIntVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestLongVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestShortVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/irTests/CmpUWithZero.java: verify that x <u 1 is transformed to x == 0
compiler/c2/irTests/TestDebugInfo.java: Verify that debug information in C2 compiled code is correct.
compiler/c2/irTests/TestFewIterationsCountedLoop.java: Add Tests to verify single iteration loops are properly optimized
compiler/c2/irTests/TestScalarReplacement.java: Test various scalarization scenarios
compiler/c2/irTests/TestScheduleSmallMethod.java: Test that small method with runtime calls can be scheduled.
compiler/c2/irTests/TestSkeletonPredicates.java: C2: Improve identical back-to-back if elimination
compiler/c2/irTests/TestStripMiningDropsSafepoint.java: When loop strip mining fails, safepoints are removed from loop anyway
compiler/c2/irTests/TestSuperwordFailsUnrolling.java: C2: loop candidate for superword not always unrolled fully if superword fails
compiler/c2/irTests/blackhole/BlackholeHotInlineTest.java: Blackholes should work when hot inlined
compiler/c2/irTests/blackhole/BlackholeLoadOptoTest.java: Blackholes should allow load optimizations
compiler/c2/irTests/blackhole/BlackholeStoreStoreEATest.java: Blackhole arguments are globally escaping, thus preventing advanced EA optimizations
compiler/c2/irTests/blackhole/BlackholeSyncEATest.java: Blackhole arguments are globally escaping, thus preventing advanced EA optimizations
compiler/c2/irTests/stringopts/TestNegativeArraySize.java: C2 applies string opts to StringBuilder object created with a negative size and misses the NegativeArraySizeException.
compiler/calls/NativeCalls.java: check that native methods get compiled
compiler/calls/TestDirtyInt.java:
compiler/calls/fromCompiled/CompiledInvokeDynamic2CompiledTest.java: check calls from compiled to compiled using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeDynamic2InterpretedTest.java: check calls from compiled to interpreted using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeDynamic2NativeTest.java: check calls from compiled to native using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeInterface2CompiledTest.java: check calls from compiled to compiled using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeInterface2InterpretedTest.java: check calls from compiled to interpreted using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeInterface2NativeTest.java: check calls from compiled to native using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeSpecial2CompiledTest.java: check calls from compiled to compiled using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeSpecial2InterpretedTest.java: check calls from compiled to interpreted using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeSpecial2NativeTest.java: check calls from compiled to native using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeStatic2CompiledTest.java: check calls from compiled to compiled using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeStatic2InterpretedTest.java: check calls from compiled to interpreted using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeStatic2NativeTest.java: check calls from compiled to native using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeVirtual2CompiledTest.java: check calls from compiled to compiled using InvokeVirtual
compiler/calls/fromCompiled/CompiledInvokeVirtual2InterpretedTest.java: check calls from compiled to interpreted using InvokeVirtual
compiler/calls/fromCompiled/CompiledInvokeVirtual2NativeTest.java: check calls from compiled to native using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2CompiledTest.java: check calls from interpreted to compiled using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2InterpretedTest.java: check calls from interpreted to interpreted using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2NativeTest.java: check calls from interpreted to native using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeInterface2CompiledTest.java: check calls from interpreted to compiled using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeInterface2InterpretedTest.java: check calls from interpreted to interpreted using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeInterface2NativeTest.java: check calls from interpreted to native using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2CompiledTest.java: check calls from interpreted to compiled using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2InterpretedTest.java: check calls from interpreted to interpreted using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2NativeTest.java: check calls from interpreted to native using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeStatic2CompiledTest.java: check calls from interpreted to compiled using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeStatic2InterpretedTest.java: check calls from interpreted to interpreted using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeStatic2NativeTest.java: check calls from interpreted to native using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2CompiledTest.java: check calls from interpreted to compiled using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2InterpretedTest.java: check calls from interpreted to interpreted using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2NativeTest.java: check calls from interpreted to native using InvokeVirtual
compiler/calls/fromNative/NativeInvokeSpecial2CompiledTest.java: check calls from native to compiled using InvokeSpecial
compiler/calls/fromNative/NativeInvokeSpecial2InterpretedTest.java: check calls from native to interpreted using InvokeSpecial
compiler/calls/fromNative/NativeInvokeSpecial2NativeTest.java: check calls from native to native using InvokeSpecial
compiler/calls/fromNative/NativeInvokeStatic2CompiledTest.java: check calls from native to compiled using InvokeStatic
compiler/calls/fromNative/NativeInvokeStatic2InterpretedTest.java: check calls from native to interpreted using InvokeStatic
compiler/calls/fromNative/NativeInvokeStatic2NativeTest.java: check calls from native to native using InvokeStatic
compiler/calls/fromNative/NativeInvokeVirtual2CompiledTest.java: check calls from native to compiled using InvokeVirtual
compiler/calls/fromNative/NativeInvokeVirtual2InterpretedTest.java: check calls from native to interpreted using InvokeVirtual
compiler/calls/fromNative/NativeInvokeVirtual2NativeTest.java: check calls from native to native using InvokeVirtual
compiler/cha/AbstractRootMethod.java:
compiler/cha/DefaultRootMethod.java:
compiler/cha/StrengthReduceInterfaceCall.java:
compiler/classUnloading/methodUnloading/TestMethodUnloading.java: Tests the unloading of methods to to class unloading
compiler/classUnloading/methodUnloading/TestOverloadCompileQueues.java: Test overloading the C1 and C2 compile queues with tasks.
compiler/codecache/CheckReservedInitialCodeCacheSizeArgOrder.java: Test checks that the order in which ReversedCodeCacheSize and InitialCodeCacheSize are passed to the VM is irrelevant.
compiler/codecache/CheckSegmentedCodeCache.java: Checks VM options related to the segmented code cache
compiler/codecache/CheckUpperLimit.java: Test ensures that the ReservedCodeCacheSize is at most MAXINT
compiler/codecache/CodeCacheFullCountTest.java: test for the value of full_count in the message of insufficient codecache
compiler/codecache/MHIntrinsicAllocFailureTest.java: test allocation failure of method handle intrinsic in profiled/non-profiled space
compiler/codecache/OverflowCodeCacheTest.java: testing of code cache segments overflow
compiler/codecache/cli/TestSegmentedCodeCacheOption.java: Verify SegmentedCodeCache option's processing
compiler/codecache/cli/codeheapsize/TestCodeHeapSizeOptions.java: Verify processing of options related to code heaps sizing.
compiler/codecache/cli/printcodecache/TestPrintCodeCacheOption.java: Verify that PrintCodeCache option print correct information.
compiler/codecache/jmx/BeanTypeTest.java: verify types of code cache memory pool bean
compiler/codecache/jmx/CodeHeapBeanPresenceTest.java: verify CodeHeap bean presence
compiler/codecache/jmx/GetUsageTest.java: testing of getUsage() for segmented code cache
compiler/codecache/jmx/InitialAndMaxUsageTest.java: testing of initial and max usage
compiler/codecache/jmx/ManagerNamesTest.java: verify getMemoryManageNames calls in case of segmented code cache
compiler/codecache/jmx/MemoryPoolsPresenceTest.java: verify that MemoryManagerMXBean exists for every code cache segment
compiler/codecache/jmx/PeakUsageTest.java: testing of getPeakUsage() and resetPeakUsage for segmented code cache
compiler/codecache/jmx/PoolsIndependenceTest.java: testing of getUsageThreshold()
compiler/codecache/jmx/ThresholdNotificationsTest.java: testing of getUsageThreshold()
compiler/codecache/jmx/UsageThresholdExceededSeveralTimesTest.java: verifying that getUsageThresholdCount() returns correct value after threshold has been hit several times
compiler/codecache/jmx/UsageThresholdExceededTest.java: verifying that getUsageThresholdCount() returns correct value after threshold has been hit
compiler/codecache/jmx/UsageThresholdIncreasedTest.java: verifying that threshold hasn't been hit after allocation smaller than threshold value and that threshold value can be changed
compiler/codecache/jmx/UsageThresholdNotExceededTest.java: verifying that usage threshold not exceeded while allocating less than usage threshold
compiler/codegen/BMI1.java: Support BMI1 instructions on x86/x64
compiler/codegen/BMI2.java: Support BMI2 instructions on x86/x64
compiler/codegen/BadLogicCode.java: Solaris JIT generates bad code for logic expression
compiler/codegen/BitTests.java: Use AArch64 bit-test instructions in C2
compiler/codegen/C1NullCheckOfNullStore.java: Null check is placed in a wrong place when storing a null to an object field on x64 with compressed oops off
compiler/codegen/CRCTest.java: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 and java.util.zip.Adler32
compiler/codegen/ClearArrayTest.java: Test for correct code generation by the JIT
compiler/codegen/IntRotateWithImmediate.java: Test that the rotate distance used in the rotate instruction is properly masked with 0x1f
compiler/codegen/LoadWithMask.java: Invalid node sizing for loadUS2L_immI16 and loadI2L_immI
compiler/codegen/LoadWithMask2.java: loadI2L_immI broken for negative memory values
compiler/codegen/ShiftByZero.java: Test shift by 0
compiler/codegen/ShiftTest.java: Test for correct code generation by the JIT
compiler/codegen/Test6378821.java: where available, bitCount() should use POPC on SPARC processors and AMD+10h
compiler/codegen/Test6431242.java:
compiler/codegen/Test6797305.java: Add LoadUB and LoadUI opcode class
compiler/codegen/Test6814842.java: Load shortening optimizations
compiler/codegen/Test6823354.java: These methods can be instrinsified by using bit scan, bit test, and population count instructions.
compiler/codegen/Test6875866.java: Intrinsic for String.indexOf() is broken on x86 with SSE4.2
compiler/codegen/Test6879902.java: CTW failure jdk6_18/hotspot/src/cpu/sparc/vm/assembler_sparc.hpp:845
compiler/codegen/Test6909839.java: missing unsigned compare cases for some cmoves in sparc.ad
compiler/codegen/Test6935535.java#id0: String.indexOf() returns incorrect result on x86 with SSE4.2
compiler/codegen/Test6942326.java: x86 code in string_indexof() could read beyond reserved heap space
compiler/codegen/Test7009231.java: C1: Incorrect CAS code for longs on SPARC 32bit
compiler/codegen/Test7100757.java: The BitSet.nextSetBit() produces incorrect result in 32bit VM on Sparc
compiler/codegen/Test8005033.java: On sparcv9, C2's intrinsic for Integer.bitCount(OV) returns wrong result if OV is the result of an operation with int overflow.
compiler/codegen/Test8011901.java: instruct xaddL_no_res shouldn't allow 64 bit constants.
compiler/codegen/TestBooleanVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharVect2.java#id0: incorrect results of char vectors right shift operation
compiler/codegen/TestCharVect2.java#id1: incorrect results of char vectors right shift operation
compiler/codegen/TestDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestFloatDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestGCMStorePlacement.java: Tests GCM's store placement in different scenarios (regular and OSR compilations, reducible and irreducible CFGs).
compiler/codegen/TestIntDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestMultiMemInstructionMatching.java: Test matching of instructions that have multiple memory inputs.
compiler/codegen/TestOopCmp.java: On ppc64, C1 erroneously emits a 32-bit compare instruction for oop compares.
compiler/codegen/TestShortDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestSignedMultiplyLong.java: Test some cases of combined signed multiply long operation
compiler/codegen/TestTrichotomyExpressions.java: Test that C2 correctly optimizes trichotomy expressions.
compiler/controldependency/TestAntiDependencyAfterStringInflation.java: Test correct insertion of anti-dependencies after String inflation.
compiler/controldependency/TestAntiDependencyForPinnedLoads.java: Test that MergeMem is skipped when looking for stores
compiler/controldependency/TestAntiDependentMembar.java: Test correct insertion of anti-dependencies if load is already control dependent on membar.
compiler/conversions/TestChainOfIntAddsToLongConversion.java: Tests that the optimization of a chain of integer additions followed by a long conversion does not lead to an explosion of live nodes.
compiler/conversions/TestMoveConvI2LOrCastIIThruAddIs.java: Exercises the optimization that moves integer-to-long conversions upwards through different shapes of integer addition subgraphs.
compiler/conversions/TestPrimitiveConversions.java: Test implicit narrowing conversion of primivite values at putfield.
compiler/cpuflags/RestoreMXCSR.java: Crash when using -XX:+RestoreMXCSROnJNICalls
compiler/cpuflags/TestSSE4Disabled.java: Test correct execution without SSE 4.
compiler/dependencies/MonomorphicObjectCall/TestMonomorphicObjectCall.java: Compiles a monomorphic call to finalizeObject() on a modified java.lang.Object to test C1 CHA.
compiler/eliminateAutobox/TestByteBoxing.java:
compiler/eliminateAutobox/TestDoubleBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestFloatBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestIdentityWithEliminateBoxInDebugInfo.java: Verify that box object identity matches after deoptimization when it is eliminated.
compiler/eliminateAutobox/TestIntBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestLongBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestSafepointDebugInfo.java: Verify consistency of safepoint debug info when boxes are scalar replaced during incremental inlining.
compiler/eliminateAutobox/TestShortBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestSplitThroughPhi.java: Test splitting a boxed field load through a loop Phi.
compiler/eliminateAutobox/UnsignedLoads.java:
compiler/escapeAnalysis/Test6689060.java: Escape Analysis does not work with Compressed Oops
compiler/escapeAnalysis/Test6726999.java: nsk/stress/jck12a/jck12a010 assert(n != NULL,"Bad immediate dominator info.");
compiler/escapeAnalysis/Test6775880.java: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
compiler/escapeAnalysis/Test6895383.java: JCK test throws NPE for method compiled with Escape Analysis
compiler/escapeAnalysis/Test6896727.java: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys w/o COOPs
compiler/escapeAnalysis/Test8020215.java: Different execution plan when using JIT vs interpreter
compiler/escapeAnalysis/TestAllocatedEscapesPtrComparison.java: bcEscapeAnalyzer allocated_escapes not conservative enough
compiler/escapeAnalysis/TestArrayCopy.java: The elimination of System.arraycopy by EscapeAnalysis prevents an IndexOutOfBoundsException from being thrown if the arraycopy is called with a negative length argument.
compiler/escapeAnalysis/TestBrokenEA.java: EA does not propagate NSR (not scalar replaceable) state.
compiler/escapeAnalysis/TestCopyOfBrokenAntiDependency.java: CTW: C2 compilation fails with "assert(store != load->find_exact_control(load->in(0))) failed: dependence cycle found"
compiler/escapeAnalysis/TestEABadMergeMem.java: Bad rewiring of memory edges when we split unique types during EA
compiler/escapeAnalysis/TestEliminateAllocation.java: The enhancement eliminates all allocations in the loop body of test() due to an improved field zeroing elimination dominance check.
compiler/escapeAnalysis/TestEliminateLocksOffCrash.java: C2 compilation fails with "graph should be schedulable" when running with -XX:-EliminateLocks
compiler/escapeAnalysis/TestEscapeThroughInvoke.java: Tests C2 EA with allocated object escaping through a call.
compiler/escapeAnalysis/TestGetClass.java: BCEscapeAnalyzer assigns wrong escape state to getClass return value.
compiler/escapeAnalysis/TestIdealAllocShape.java: full loop unroll before EA creates phis between allocs projs and init
compiler/escapeAnalysis/TestMissingAntiDependency.java: 8240795 may cause anti-dependency to be missed
compiler/escapeAnalysis/TestSelfArrayCopy.java: Test correct elimination of array allocation with arraycopy to itself.
compiler/escapeAnalysis/TestUnsafePutAddressNullObjMustNotEscape.java: assert(null_obj->escape_state() == PointsToNode::NoEscape,etc)
compiler/escapeAnalysis/TestValAtSafepointOverflowsInt.java: C2 compilation fails with assert(!had_error) failed: bad dominance
compiler/escapeAnalysis/cr6716441/Tester.java: error in meet with +DoEscapeAnalysis
compiler/escapeAnalysis/cr6795161/Test.java: Escape analysis leads to data corruption
compiler/exceptions/CatchInlineExceptions.java: assert(adr_type != NULL) failed: expecting TypeKlassPtr
compiler/exceptions/ExceptionInInit.java: Attempt to read inaccessible property can produce exception of the wrong type.
compiler/exceptions/SumTest.java: FP registers are not properly restored by C1 when handling exceptions
compiler/exceptions/TestC1ExceptionHandlersSameBCI.java: assert failure with 2 handlers at same bci
compiler/exceptions/TestLateMHInlineExceptions.java: GraphKit::combine_exception_states fails with "matching stack sizes" assert
compiler/exceptions/TestRecursiveReplacedException.java: Recursive method compiled by C1 is unable to catch StackOverflowError
compiler/floatingpoint/ModNaN.java: double a%b returns NaN for some (a,b) (|a| < inf, |b|>0) (on Core i7 980X)
compiler/floatingpoint/NaNTest.java: Verify if signaling NaNs are preserved.
compiler/floatingpoint/TestFMA.java: intrinsify fused mac operations
compiler/floatingpoint/TestFMABrokenC1RegAlloc.java: C1's Math.fma() intrinsic doesn't correctly marks its inputs
compiler/floatingpoint/TestFloatJNIArgs.java#id0: Regression test for passing float args to a jni function.
compiler/floatingpoint/TestFloatJNIArgs.java#id1: Regression test for passing float args to a jni function.
compiler/floatingpoint/TestFloatSyncJNIArgs.java: Regression test for passing float args to a synchronized jni function.
compiler/floatingpoint/TestLibmIntrinsics.java: Test libm intrinsics
compiler/floatingpoint/TestPow2.java: X^2 special case for C2 yields different result than interpreter
compiler/floatingpoint/TestRound.java: calling Math.round(NaN) can break subsequent calls to Math.round()
compiler/gcbarriers/EqvUncastStepOverBarrier.java: Node::eqv_uncast() shouldn't step over load barriers unconditionally
compiler/gcbarriers/G1CrashTest.java: C2 optimization breaks with G1
compiler/gcbarriers/TestAlwaysAtomicAccesses.java: Test memory accesses from compiled code with AlwaysAtomicAccesses.
compiler/gcbarriers/TestMembarDependencies.java: Tests correct scheduling of memory loads around MembarVolatile emitted by GC barriers.
compiler/gcbarriers/UnsafeIntrinsicsTest.java#shenandoah: Validate barriers after Unsafe getReference, CAS and swap (GetAndSet)
compiler/gcbarriers/UnsafeIntrinsicsTest.java#z: Validate barriers after Unsafe getReference, CAS and swap (GetAndSet)
compiler/inlining/DefaultAndConcreteMethodsCHA.java: CHA ignores default methods during analysis leading to incorrect code generation
compiler/inlining/DefaultMethodsDependencies.java: Deoptimization between array allocation and arraycopy may result in non initialized array
compiler/inlining/InlineAccessors.java: Method::is_accessor should cover getters and setters for all types
compiler/inlining/InlineDefaultMethod.java: CHA in C1 should make correct decisions about default methods
compiler/inlining/InlineDefaultMethod1.java: Default method returns true for a while, and then returns false
compiler/inlining/LateInlineVirtualNullReceiverCheck.java:
compiler/inlining/PrintInlining.java: PrintInlining as compiler directive doesn't print virtual calls
compiler/inlining/ResolvedClassTest.java:
compiler/inlining/StringConcatInfiniteLoop.java: Multiple passes of PhaseRemoveUseless causes infinite loop to be optimized out
compiler/integerArithmetic/MultiplyByConstantLongMax.java: test/hotspot/jtreg/compiler/intrinsics/mathexact/MulExactLConstantTest.java fails on Windows x64 when run with -XX:-TieredCompilation
compiler/integerArithmetic/MultiplyByIntegerMinHang.java: C2 may hang in MulLNode::Ideal()/MulINode::Ideal() with gcc 8.2.1
compiler/integerArithmetic/TestIntegerComparison.java: Tests optimizations of signed and unsigned integer comparison.
compiler/integerArithmetic/TestNegAnd.java: Test broken transformation (-a) & (-b) = a & b does not happen
compiler/integerArithmetic/TestNegMultiply.java: Test transformation (-a)*(-b) = a*b
compiler/interpreter/DisableOSRTest.java: testing that -XX:-UseOnStackReplacement works with both -XX:(+/-)TieredCompilation
compiler/interpreter/Test6539464.java: Math.log() produces inconsistent results between successive runs.
compiler/interpreter/Test6833129.java: Object.clone() and Arrays.copyOf ignore coping with -XX:+DeoptimizeALot
compiler/interpreter/TestVerifyStackAfterDeopt.java: Checks VerifyStack after deoptimization of array allocation slow call
compiler/interpreter/VerifyStackWithUnreachableBlock.java: Using VerifyStack for method that contains unreachable basic blocks
compiler/interpreter/cr7116216/StackOverflow.java: The vm crashes when GC happens during throwing a StackOverflow exception
compiler/intrinsics/IntrinsicAvailableTest.java:
compiler/intrinsics/IntrinsicDisabledTest.java:
compiler/intrinsics/Test6982370.java: SIGBUS in jbyte_fill
compiler/intrinsics/Test8005419.java: Improve intrinsics code performance on x86 by using AVX2
compiler/intrinsics/Test8215792.java: Fix a bug in AArch64 string intrinsics
compiler/intrinsics/Test8237524.java: String.compareTo() may return incorrect result in this case
compiler/intrinsics/TestCheckIndex.java: Add utility methods to check long indexes and ranges
compiler/intrinsics/TestReferenceGetWithNull.java: Test that the Reference::get intrinsic works with a null argument.
compiler/intrinsics/TestReferenceRefersTo.java: Based on test/jdk/java/lang/ref/ReferenceRefersTo.java.
compiler/intrinsics/TestRotate.java: Support for scalar rotates ([Integer/Long].rotate[Left/Right]).
compiler/intrinsics/VectorizedMismatchTest.java:
compiler/intrinsics/bigInteger/MontgomeryMultiplyTest.java: Verify that the Montgomery multiply and square intrinsic works and correctly checks their arguments.
compiler/intrinsics/bigInteger/TestMulAdd.java: Add C2 x86 intrinsic for BigInteger::mulAdd() method
compiler/intrinsics/bigInteger/TestMultiplyToLen.java: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
compiler/intrinsics/bigInteger/TestMultiplyToLenReturnProfile.java: MultiplyToLen sets its return type to have a bottom offset which confuses code generation
compiler/intrinsics/bigInteger/TestShift.java: Add C2 x86 intrinsic for BigInteger::shiftLeft() and BigInteger::shiftRight() method
compiler/intrinsics/bigInteger/TestSquareToLen.java: Add C2 x86 intrinsic for BigInteger::squareToLen() method
compiler/intrinsics/bmi/TestAndnI.java: Verify that results of computations are the same w/ and w/o usage of ANDN instruction
compiler/intrinsics/bmi/TestAndnL.java: Verify that results of computations are the same w/ and w/o usage of ANDN instruction
compiler/intrinsics/bmi/TestBlsiI.java: Verify that results of computations are the same w/ and w/o usage of BLSI instruction
compiler/intrinsics/bmi/TestBlsiL.java: Verify that results of computations are the same w/ and w/o usage of BLSI instruction
compiler/intrinsics/bmi/TestBlsmskI.java: Verify that results of computations are the same w/ and w/o usage of BLSMSK instruction
compiler/intrinsics/bmi/TestBlsmskL.java: Verify that results of computations are the same w/ and w/o usage of BLSMSK instruction
compiler/intrinsics/bmi/TestBlsrI.java: Verify that results of computations are the same w/ and w/o usage of BLSR instruction
compiler/intrinsics/bmi/TestBlsrL.java: Verify that results of computations are the same w/ and w/o usage of BLSR instruction
compiler/intrinsics/bmi/TestBzhiI2L.java: Verify that results of computations are the same w/ and w/o usage of BZHI instruction
compiler/intrinsics/bmi/TestLzcntI.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestLzcntL.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestTzcntI.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestTzcntL.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/verifycode/AndnTestI.java:
compiler/intrinsics/bmi/verifycode/AndnTestL.java:
compiler/intrinsics/bmi/verifycode/BlsiTestI.java:
compiler/intrinsics/bmi/verifycode/BlsiTestL.java:
compiler/intrinsics/bmi/verifycode/BlsmskTestI.java:
compiler/intrinsics/bmi/verifycode/BlsmskTestL.java:
compiler/intrinsics/bmi/verifycode/BlsrTestI.java:
compiler/intrinsics/bmi/verifycode/BlsrTestL.java:
compiler/intrinsics/bmi/verifycode/BzhiTestI2L.java:
compiler/intrinsics/bmi/verifycode/LZcntTestI.java:
compiler/intrinsics/bmi/verifycode/LZcntTestL.java:
compiler/intrinsics/bmi/verifycode/TZcntTestI.java:
compiler/intrinsics/bmi/verifycode/TZcntTestL.java:
compiler/intrinsics/klass/CastNullCheckDroppingsTest.java: Casting can result in redundant null checks in generated code
compiler/intrinsics/klass/TestGetModifiers.java#id0:
compiler/intrinsics/klass/TestGetModifiers.java#id1:
compiler/intrinsics/klass/TestGetModifiers.java#id2:
compiler/intrinsics/klass/TestIsPrimitive.java: C1 intrinsic for Class.isPrimitive
compiler/intrinsics/math/MaxMinOptimizeTest.java: Test the result of 8263006's optimization
compiler/intrinsics/math/Test8210461.java: Math cos instrinsic returns incorrect result for large value
compiler/intrinsics/math/TestFpMinMaxIntrinsics.java: Test compiler intrinsics of floating-point Math.min/max
compiler/intrinsics/math/TestMinMaxIntrinsics.java: Test integer min and max intrinsics
compiler/intrinsics/math/TestPow0Dot5Opt.java: test the optimization of pow(x, 0.5)
compiler/intrinsics/math/TestPow2Opt.java: test the optimization of pow(x, 2.0)
compiler/intrinsics/math/TestSignumIntrinsic.java: Test compiler intrinsics for signum
compiler/intrinsics/mathexact/AddExactICondTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactIConstantTest.java: Test constant addExact
compiler/intrinsics/mathexact/AddExactILoadTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactILoopDependentTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactINonConstantTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactIRepeatTest.java: Test repeating addExact
compiler/intrinsics/mathexact/AddExactLConstantTest.java: Test constant addExact
compiler/intrinsics/mathexact/AddExactLNonConstantTest.java: Test non constant addExact
compiler/intrinsics/mathexact/CompareTest.java: Verify that the compare after addExact is a signed compare
compiler/intrinsics/mathexact/DecExactITest.java: Test decrementExact
compiler/intrinsics/mathexact/DecExactLTest.java: Test decrementExact
compiler/intrinsics/mathexact/GVNTest.java: Verify that GVN doesn't mess up the two addExacts
compiler/intrinsics/mathexact/IncExactITest.java: Test incrementExact
compiler/intrinsics/mathexact/IncExactLTest.java: Test incrementExact
compiler/intrinsics/mathexact/LongMulOverflowTest.java: Regression test for multiplyExact intrinsic
compiler/intrinsics/mathexact/MulExactICondTest.java: Test multiplyExact as condition
compiler/intrinsics/mathexact/MulExactIConstantTest.java: Test constant multiplyExact
compiler/intrinsics/mathexact/MulExactILoadTest.java: Test multiplyExact
compiler/intrinsics/mathexact/MulExactILoopDependentTest.java: Test loop dependent multiplyExact
compiler/intrinsics/mathexact/MulExactINonConstantTest.java: Test non constant multiplyExact
compiler/intrinsics/mathexact/MulExactIRepeatTest.java: Test repeating multiplyExact
compiler/intrinsics/mathexact/MulExactLConstantTest.java: Test constant mulExact
compiler/intrinsics/mathexact/MulExactLNonConstantTest.java: Test non constant mulExact
compiler/intrinsics/mathexact/NegExactIConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NegExactILoadTest.java: Test negExact
compiler/intrinsics/mathexact/NegExactILoopDependentTest.java: Test negExact loop dependent
compiler/intrinsics/mathexact/NegExactINonConstantTest.java: Test non constant negExact
compiler/intrinsics/mathexact/NegExactLConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NegExactLNonConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NestedMathExactTest.java: Test nested loops
compiler/intrinsics/mathexact/SplitThruPhiTest.java: Verify that split through phi does the right thing
compiler/intrinsics/mathexact/SubExactICondTest.java: Test subtractExact as condition
compiler/intrinsics/mathexact/SubExactIConstantTest.java: Test constant subtractExact
compiler/intrinsics/mathexact/SubExactILoadTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactILoopDependentTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactINonConstantTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactIRepeatTest.java: Test repeating subtractExact
compiler/intrinsics/mathexact/SubExactLConstantTest.java: Test constant subtractExact
compiler/intrinsics/mathexact/SubExactLNonConstantTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/sanity/AddExactIntTest.java:
compiler/intrinsics/mathexact/sanity/AddExactLongTest.java:
compiler/intrinsics/mathexact/sanity/DecrementExactIntTest.java:
compiler/intrinsics/mathexact/sanity/DecrementExactLongTest.java:
compiler/intrinsics/mathexact/sanity/IncrementExactIntTest.java:
compiler/intrinsics/mathexact/sanity/IncrementExactLongTest.java:
compiler/intrinsics/mathexact/sanity/MultiplyExactIntTest.java:
compiler/intrinsics/mathexact/sanity/MultiplyExactLongTest.java:
compiler/intrinsics/mathexact/sanity/NegateExactIntTest.java:
compiler/intrinsics/mathexact/sanity/NegateExactLongTest.java:
compiler/intrinsics/mathexact/sanity/SubtractExactIntTest.java:
compiler/intrinsics/mathexact/sanity/SubtractExactLongTest.java:
compiler/intrinsics/object/TestClone.java: assert(ex_map->jvms()->same_calls_as(_exceptions->jvms())) failed: all collected exceptions must come from the same place
compiler/intrinsics/object/TestHashCode.java: SEGV in compiled code with loop predication
compiler/intrinsics/sha/TestDigest.java: C2 support for MD5/SHA-1/SHA-224/SHA-256/SHA-384/SHA-512/SHA3
compiler/intrinsics/sha/cli/TestUseMD5IntrinsicsOptionOnSupportedCPU.java: Verify UseMD5Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseMD5IntrinsicsOptionOnUnsupportedCPU.java: Verify UseMD5Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA1Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA1Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA256Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA256Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA3IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA3Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA512Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA512Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHAOptionOnSupportedCPU.java: Verify UseSHA option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java: Verify UseSHA option processing on unsupported CPU.
compiler/intrinsics/sha/sanity/TestMD5Intrinsics.java: Verify that MD5 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestMD5MultiBlockIntrinsics.java: Verify that MD5 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA1Intrinsics.java: Verify that SHA-1 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA1MultiBlockIntrinsics.java: Verify that SHA-1 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA256Intrinsics.java: Verify that SHA-256 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA256MultiBlockIntrinsics.java: Verify that SHA-256 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA3Intrinsics.java: Verify that SHA3-224, SHA3-256, SHA3-384, SHA3-512 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA3MultiBlockIntrinsics.java: Verify that SHA3-224, SHA3-256, SHA3-384, SHA3-512 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA512Intrinsics.java: Verify that SHA-512 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA512MultiBlockIntrinsics.java: Verify that SHA-512 multi block intrinsic is actually used.
compiler/intrinsics/string/TestCopyValueOf.java: Verify that String.copyValueOf properly handles null input with intrinsified helper methods.
compiler/intrinsics/string/TestEncodeIntrinsics.java: Verify potentially intrinsified encoders behave well before and after compilation
compiler/intrinsics/string/TestHasNegatives.java: Validates StringCoding.hasNegatives intrinsic with a small range of tests.
compiler/intrinsics/string/TestStringConstruction.java: Tests handling of invalid array indices in C2 intrinsic if explicit range check in Java code is not inlined.
compiler/intrinsics/string/TestStringEqualsBadLength.java: String.equals() may be called with a length whose upper bits are not cleared
compiler/intrinsics/string/TestStringIndexOfCharIntrinsics.java: Check for correct return value when calling indexOfChar intrinsics with negative value.
compiler/intrinsics/string/TestStringIntrinsicMemoryFlow.java: Check for correct memory flow with the String compress/inflate intrinsics.
compiler/intrinsics/string/TestStringIntrinsicRangeChecks.java: Verifies that string intrinsics throw array out of bounds exceptions.
compiler/intrinsics/string/TestStringIntrinsics.java: Tests correctness of string related intrinsics and C2 optimizations.
compiler/intrinsics/string/TestStringIntrinsics2.java: PPC64: fix string intrinsics after CompactStrings change
compiler/intrinsics/string/TestStringLatin1IndexOfChar.java: Test intrinsification of StringLatin1.indexOf(char).
compiler/intrinsics/string/TestStringUTF16IntrinsicRangeChecks.java: Verifies that callers of StringUTF16 intrinsics throw array out of bounds exceptions.
compiler/intrinsics/unsafe/AllocateUninitializedArray.java: Unsafe methods to produce uninitialized arrays
compiler/intrinsics/unsafe/DirectByteBufferTest.java: Verify that direct byte buffers are correctly accessed.
compiler/intrinsics/unsafe/HeapByteBufferTest.java#id0: Verify that byte buffers are correctly accessed.
compiler/intrinsics/unsafe/HeapByteBufferTest.java#id1: intermittent, check that spilling MoveF2I etc produce memory edge
compiler/intrinsics/unsafe/TestCAEAntiDep.java: Unsafe.compareAndExchangeReference should keep track of returned type after matching
compiler/intrinsics/unsafe/TestUnsafeMismatchedArrayFieldAccess.java: Unsafe access to an array is wrongly marked as mismatched
compiler/intrinsics/unsafe/TestUnsafeUnalignedMismatchedAccesses.java: Mismatched stores on same slice possible with Unsafe.Put*Unaligned methods
compiler/intrinsics/unsafe/UnsafeGetAddressTest.java: C2 intrinsic for Unsafe.getAddress performs pointer sign extension on 32-bit systems
compiler/intrinsics/unsafe/UnsafeTwoCASLong.java: C1 LinearScan asserts when compiling two back-to-back CompareAndSwapLongs
compiler/intrinsics/zip/TestAdler32.java: C2 support for Adler32 on SPARC
compiler/intrinsics/zip/TestCRC32.java: CRC32 Intrinsics support on SPARC
compiler/intrinsics/zip/TestCRC32C.java: C2 support for CRC32C on SPARC
compiler/jsr292/CallSiteDepContextTest.java:
compiler/jsr292/ConcurrentClassLoadingTest.java: JSR292: deadlock during class loading of MethodHandles, MethodHandleImpl & MethodHandleNatives
compiler/jsr292/ContinuousCallSiteTargetChange.java:
compiler/jsr292/CreatesInterfaceDotEqualsCallInfo.java: MethodHandle lookup for an interface method causes assertion failure in linkResolver.cpp
compiler/jsr292/InvokerGC.java:
compiler/jsr292/InvokerSignatureMismatch.java:
compiler/jsr292/LongReferenceCastingTest.java: Test correct casting of MH arguments during inlining.
compiler/jsr292/MHInlineTest.java: C2: inlining failure due to access checks being too strict
compiler/jsr292/NonInlinedCall/InvokeTest.java:
compiler/jsr292/NonInlinedCall/RedefineTest.java:
compiler/jsr292/NullConstantMHReceiver.java:
compiler/jsr292/NullConstantReceiver.java:
compiler/jsr292/PollutedTrapCounts.java:
compiler/jsr292/RedefineMethodUsedByMultipleMethodHandles.java: redefining method used by multiple MethodHandles crashes VM
compiler/jsr292/Test7082949.java: JSR 292: missing ResourceMark in methodOopDesc::make_invoke_method
compiler/jsr292/TestArrayReturnType.java:
compiler/jsr292/cr6990212/Test6990212.java: JSR 292 JVMTI MethodEnter hook is not called for JSR 292 bootstrap and target methods
compiler/jsr292/cr8026328/Test8026328.java:
compiler/jsr292/methodHandleExceptions/TestAMEnotNPE.java: Ensure that correct exceptions are thrown, not NullPointerException
compiler/jvmci/JVM_GetJVMCIRuntimeTest.java:
compiler/jvmci/SecurityRestrictionsTest.java:
compiler/jvmci/TestEnableJVMCIProduct.java: Tests effect of -XX:+EnableJVMCIProduct on EnableJVMCI and UseJVMCICompiler
compiler/jvmci/TestInvalidJVMCIOption.java: Ensures invalid JVMCI options do not crash the VM with a hs-err log.
compiler/jvmci/TestJVMCIPrintProperties.java: Ensure -XX:-JVMCIPrintProperties can be enabled and successfully prints expected output to stdout.
compiler/jvmci/TestValidateModules.java: Ensure java --validate-modules works with --XX:+EnableJVMCI
compiler/jvmci/compilerToVM/AllocateCompileIdTest.java:
compiler/jvmci/compilerToVM/AsResolvedJavaMethodTest.java:
compiler/jvmci/compilerToVM/CollectCountersTest.java:
compiler/jvmci/compilerToVM/DisassembleCodeBlobTest.java:
compiler/jvmci/compilerToVM/DoNotInlineOrCompileTest.java:
compiler/jvmci/compilerToVM/FindUniqueConcreteMethodTest.java:
compiler/jvmci/compilerToVM/GetBytecodeTest.java:
compiler/jvmci/compilerToVM/GetClassInitializerTest.java:
compiler/jvmci/compilerToVM/GetExceptionTableTest.java:
compiler/jvmci/compilerToVM/GetImplementorTest.java:
compiler/jvmci/compilerToVM/GetLineNumberTableTest.java:
compiler/jvmci/compilerToVM/GetMaxCallTargetOffsetTest.java:
compiler/jvmci/compilerToVM/GetStackTraceElementTest.java:
compiler/jvmci/compilerToVM/GetSymbolTest.java:
compiler/jvmci/compilerToVM/GetVtableIndexForInterfaceTest.java:
compiler/jvmci/compilerToVM/HasCompiledCodeForOSRTest.java:
compiler/jvmci/compilerToVM/HasFinalizableSubclassTest.java:
compiler/jvmci/compilerToVM/HasNeverInlineDirectiveTest.java:
compiler/jvmci/compilerToVM/IsCompilableTest.java#id1:
compiler/jvmci/compilerToVM/IsMatureTest.java:
compiler/jvmci/compilerToVM/IsMatureVsReprofileTest.java:
compiler/jvmci/compilerToVM/LookupKlassInPoolTest.java: Testing compiler.jvmci.CompilerToVM.lookupKlassInPool method
compiler/jvmci/compilerToVM/LookupKlassRefIndexInPoolTest.java:
compiler/jvmci/compilerToVM/LookupMethodInPoolTest.java:
compiler/jvmci/compilerToVM/LookupNameAndTypeRefIndexInPoolTest.java:
compiler/jvmci/compilerToVM/LookupNameInPoolTest.java:
compiler/jvmci/compilerToVM/LookupSignatureInPoolTest.java:
compiler/jvmci/compilerToVM/LookupTypeTest.java:
compiler/jvmci/compilerToVM/MaterializeVirtualObjectTest.java:
compiler/jvmci/compilerToVM/MethodIsIgnoredBySecurityStackWalkTest.java:
compiler/jvmci/compilerToVM/ReadConfigurationTest.java:
compiler/jvmci/compilerToVM/ReprofileTest.java:
compiler/jvmci/compilerToVM/ResolveFieldInPoolTest.java:
compiler/jvmci/compilerToVM/ResolveMethodTest.java:
compiler/jvmci/compilerToVM/ResolvePossiblyCachedConstantInPoolTest.java:
compiler/jvmci/compilerToVM/ResolveTypeInPoolTest.java: Testing compiler.jvmci.CompilerToVM.resolveTypeInPool method
compiler/jvmci/compilerToVM/ShouldDebugNonSafepointsTest.java:
compiler/jvmci/compilerToVM/ShouldInlineMethodTest.java:
compiler/jvmci/errors/TestInvalidCompilationResult.java:
compiler/jvmci/errors/TestInvalidDebugInfo.java:
compiler/jvmci/errors/TestInvalidOopMap.java:
compiler/jvmci/errors/TestInvalidTieredStopAtLevel.java:
compiler/jvmci/events/JvmciNotifyBootstrapFinishedEventTest.java:
compiler/jvmci/events/JvmciNotifyInstallEventTest.java:
compiler/jvmci/events/JvmciShutdownEventTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/DataPatchTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/InterpreterFrameSizeTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/MaxOopMapStackOffsetTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/NativeCallTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/SimpleCodeInstallationTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/SimpleDebugInfoTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/VirtualObjectDebugInfoTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotConstantReflectionProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotResolvedJavaFieldTest.java: Tests HotSpotResolvedJavaField functionality
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MethodHandleAccessProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestDynamicConstant.java: Test CONSTANT_Dynamic resolution by HotSpotConstantPool.
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotJVMCIRuntime.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotResolvedJavaField.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotSpeculationLog.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestServices.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestTranslatedException.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/VirtualObjectLayoutTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ConstantPoolTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ConstantTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/RedefineClassTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ResolvedJavaTypeResolveConcreteMethodTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ResolvedJavaTypeResolveMethodTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestBytecodeFrame.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestConstantReflectionProvider.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaField.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaMethod.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaType.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestMetaAccessProvider.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaField.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestSingleImplementor.java: Verify single interface implementor recording supports diamond-shaped class hierarchies
compiler/jvmci/meta/StableFieldTest.java:
compiler/linkage/LinkageErrors.java:
compiler/linkage/TestLinkageErrorInGenerateOopMap.java: Test OSR compilation with bad operand stack.
compiler/locks/TestNestedLocksElimination.java: Nested locks optimization may create unbalanced monitor enter/exit code
compiler/locks/TestUnlockOSR.java: During OSR, locks get transferred from interpreter frame.
compiler/longcountedloops/TestDeadLongPhi.java: C2: assert(!had_error) failed: bad dominance
compiler/longcountedloops/TestIVPhiTypeIncorrectAfterCCP.java: Incorrect type for IV phi of long counted loops after CCP
compiler/longcountedloops/TestLongCountedLoopSplitIf.java: cmp != __null && cmp->Opcode() == Op_CmpL failure with -XX:StressLongCountedLoop=200000000 in lucene
compiler/longcountedloops/TestTooManyLoopOpts.java: C2: assert(!n->as_Loop()->is_transformed_long_loop()) failure with -XX:StressLongCountedLoop=1
compiler/loopopts/BadPredicateAfterPartialPeel.java: Predicate moved after partial peel may lead to broken graph
compiler/loopopts/ConstFPVectorization.java: C2 code generator can replace -0.0f with +0.0f on Linux
compiler/loopopts/CountedLoopPeelingProfilePredicates.java: CountedLoopEndNode from peeled loop body is not candidate for profile loop predication
compiler/loopopts/CountedLoopProblem.java: Inner loop induction variable increment occurs before compare which causes integer overflow
compiler/loopopts/FillArrayWithUnsafe.java: Fill a byte array with Java Unsafe API
compiler/loopopts/InfiniteLoopBadControlNeverBranch.java: C2: assert(!loop->is_member(get_loop(useblock))) failed: must be outside loop
compiler/loopopts/IterationSplitPredicateInconsistency.java: Bad graph when unrolled loop bounds conflicts with range checks
compiler/loopopts/LoadVectorFromStableArray.java: LoadVector from a known element of a stable array shouldn't attempt to constant fold
compiler/loopopts/LoopRotateBadNodeBudget.java: Node estimate for loop rotate is not correct/sufficient: assert(delta <= 2 * required) failed: Bad node estimate ...
compiler/loopopts/LoopUnrollBadNodeBudget.java: Node estimate for loop unrolling is not correct/sufficient: assert(delta <= 2 * required) failed: Bad node estimate ...
compiler/loopopts/LoopUnswitchingBadNodeBudget.java: Node estimate for loop unswitching is not correct: assert(delta <= 2 * required) failed: Bad node estimate
compiler/loopopts/PartialPeelingUnswitch.java: Tests if partially peeled statements are not executed before the loop predicates by bailing out of loop unswitching.
compiler/loopopts/PeelingAndLoopStripMining.java: Tests dominance in PhaseIdealLoop::get_early_ctrl_for_expensive() if an expensive SqrtD node is peeled.
compiler/loopopts/PeelingZeroTripCount.java: C2 crash in loopTransform.cpp with assert(cl->trip_count() > 0) failed: peeling a fully unrolled loop
compiler/loopopts/SplitIfSharedFastLockBehindCastPP.java: assert(bol->is_Bool()) crash during split if due to FastLockNode
compiler/loopopts/StoreMovedBeforeInfiniteLoop.java: assert(is_Loop()) crash in PhaseIdealLoop::try_move_store_before_loop()
compiler/loopopts/Test6659207.java: access violation in CompilerThread0
compiler/loopopts/Test6855164.java: SIGSEGV during compilation of method involving loop over CharSequence
compiler/loopopts/Test6860469.java: remix_address_expressions reshapes address expression with bad control
compiler/loopopts/Test7044738.java: Loop unroll optimization causes incorrect result
compiler/loopopts/Test7052494.java: Eclipse test fails on JDK 7 b142
compiler/loopopts/Test8210392.java: C2 Assert failure: Live node limit exceeded
compiler/loopopts/Test8211698.java: Crash in C2 compiled code during execution of double array heavy processing code
compiler/loopopts/TestAddPChainWithDifferentBase.java: C2: assert(!addp->is_AddP() || addp->in(AddPNode::Base)->is_top() || addp->in(AddPNode::Base) == n->in(AddPNode::Base)) failed: Base pointers must match (addp 1301)
compiler/loopopts/TestArraysFillDeadControl.java: Array.fill intrinsification code doesn't mark replaced control as dead
compiler/loopopts/TestBackedgeLoadArrayFillMain.java: ArrayFill: if store is on backedge, last iteration is not to be executed.
compiler/loopopts/TestBadControlAfterPreMainPost.java: C2: "control input must dominate current control" assert failure
compiler/loopopts/TestBadControlLoopLimitCheck.java: "Bad graph detected in build_loop_late" when loads are pinned on loop limit check uncommon branch
compiler/loopopts/TestBadlyFormedCountedLoop.java: CountedLoopEndNode::stride_con crash in debug build with -XX:+TraceLoopOpts
compiler/loopopts/TestBeautifyLoops.java: JVM crashes after transformation in C2 IdealLoopTree::merge_many_backedges
compiler/loopopts/TestBeautifyLoops_2.java: JVM crashes after transformation in C2 IdealLoopTree::split_fall_in
compiler/loopopts/TestBrokenAntiDependenceWithPhi.java: C2: assert(early->dominates(LCA)) failed: early is high enough
compiler/loopopts/TestCMovSplitThruPhi.java: C2 conditonal move optimization might create broken graph
compiler/loopopts/TestCMovWithOpaque.java: Test conditional move optimization encountering an Opaque4Node.
compiler/loopopts/TestCMoveWithDeadPhi.java: Test conditional move optimization with a TOP PhiNode.
compiler/loopopts/TestCastFFAtPhi.java: C2: assert(phi_type->isa_int() || phi_type->isa_ptr() || phi_type->isa_long()) failed: bad phi type
compiler/loopopts/TestCastIIMakesMainLoopPhiDead.java: C2: assert(!had_error) failed: bad dominance
compiler/loopopts/TestCastIINoLoopLimitCheck.java: CastII that guards counted loops confuses range check elimination with LoopLimitCheck off
compiler/loopopts/TestCountedLoopBadIVRange.java: Bad range for IV phi when exit condition is a not equal test
compiler/loopopts/TestCountedLoopSafepointBackedge.java: Safepoint on backedge breaks UseCountedLoopSafepoints
compiler/loopopts/TestCountedLoopZeroIter.java: C2: assert(inner->is_valid_counted_loop(T_INT) && inner->is_strip_mined()) failed: OuterStripMinedLoop should have been removed
compiler/loopopts/TestCreateNewIfForPredicateCloning.java: Test cloning of pinned phi input nodes in create_new_if_for_predicate().
compiler/loopopts/TestDeadBackbranchArrayAccess.java: dead backbranch in main loop results in erroneous array access
compiler/loopopts/TestDeadCountedLoop.java: C2: java/text/Normalizer/ConformanceTest.java test failed with assertion
compiler/loopopts/TestDeadPostLoopBecausePredicate.java: C2: assert(n->is_Root() || n->is_Region() || n->is_Phi() || n->is_MachMerge() || def_block->dominates(block)) failed: uses must be dominated by definitions
compiler/loopopts/TestDepBetweenLoopAndPredicate.java: RangeCheck should not be moved out of a loop if a node on the data input chain for the bool is dependent on the projection into the loop (after the predicates).
compiler/loopopts/TestDivWithTopDivisor.java: Fix "assert(_base == Int) failed: Not an Int" due to a top divisor not handled correctly in no_dependent_zero_check().
compiler/loopopts/TestDivZeroCheckControl.java#id0: Verify that zero check is executed before division/modulo operation.
compiler/loopopts/TestIdomAfterLoopUnswitching.java: Test idom data after unswitching loop following by full unroll.
compiler/loopopts/TestIfReplacedByMainLoopExit.java: C2: Incorrect computation after JDK-8269752
compiler/loopopts/TestImpossibleIV.java: C2 IV elimination throws FPE
compiler/loopopts/TestInfLoopNearUsePlacement.java: Test node placement when its use is inside infinite loop.
compiler/loopopts/TestInfiniteLoopCCP.java: Crash PhaseIdealLoop::clone_outer_loop
compiler/loopopts/TestInfiniteLoopNest.java: Assertion failure: parsing found no loops but there are some
compiler/loopopts/TestInfiniteLoopNotInnerMost.java: C2: "failed: parsing found no loops but there are some" assert failure
compiler/loopopts/TestInfiniteLoopWithUnmergedBackedgesMain.java: Infinite loops may not have the backedges merged, before we call IdealLoopTree::check_safepts
compiler/loopopts/TestIrreducibleLoopWithVNNI.java: assert(is_Loop()) failed: invalid node class, during OSR compilation for VNNI pattern match.
compiler/loopopts/TestIterationSplitWithRegionHead.java: Tests infinite loop with region head in iteration split.
compiler/loopopts/TestLimitLoadBelowLoopLimitCheck.java: C2 Crash in Node::in(unsigned int) const+0x14
compiler/loopopts/TestLoadPinnedAfterAllocate.java: C2: assert(false) failed: unscheduable graph
compiler/loopopts/TestLogSum.java: Segmentation fault in JVM (easily reproducible)
compiler/loopopts/TestLongCountedLoopInInfiniteLoop.java: C2: assert(!n->as_Loop()->is_loop_nest_inner_loop() || _loop_opts_cnt == 0) failed: should have been turned into a counted loop
compiler/loopopts/TestLoopEndNodeEliminate.java: Crashes in PhaseIdealLoop::transform_long_counted_loop
compiler/loopopts/TestLoopLimitNodeElimination.java: C2: LoopLimit node is not eliminated
compiler/loopopts/TestLoopLimitOverflowDuringCCP.java: Integer overflow in LoopLimit::Value during PhaseCCP::analyze, triggered by the Phi Node from "flag ? Integer.MAX_VALUE : 1000"
compiler/loopopts/TestLoopPeeling.java: Tests correct dominator information after loop peeling.
compiler/loopopts/TestLoopPredicateDep.java: Crashes in PhaseIdealLoop::build_loop_late_post_work
compiler/loopopts/TestMainBodyExecutedOnce.java: C2: assert(false) failed: Bad graph detected in build_loop_late
compiler/loopopts/TestMainNeverExecuted.java: C2: assert(!had_error) failed: bad dominance
compiler/loopopts/TestMaxLoopOptsCountReached.java: triggers the loop optimization phase `LoopOptsCount` many times
compiler/loopopts/TestMissedOpaqueInPredicate.java: Apache Lucene triggers: DEBUG MESSAGE: duplicated predicate failed which is impossible
compiler/loopopts/TestMoveStoreAfterInfiniteLoop.java: C2: assert(!n_loop->is_member(get_loop(lca))) failed: control must not be back in the loop
compiler/loopopts/TestMoveStoresOutOfLoops.java: Move stores out of loops if possible
compiler/loopopts/TestMoveStoresOutOfLoopsStoreNoCtrl.java: Store nodes may not have a control if used to update profiling
compiler/loopopts/TestMultipleInfiniteLoops.java: Test that blocks made unreachable after processing multiple infinite loops in the block ordering phase are removed correctly.
compiler/loopopts/TestNestedIrreducibleLoopsMain.java: Tests custom bytecode with deep nested irreducible loops.
compiler/loopopts/TestNodeSunkFromPreLoop.java: Node used in check in main loop sunk from pre loop before RC elimination
compiler/loopopts/TestOneIterationStripMined.java: Test removal of strip mined loop with only one iteration.
compiler/loopopts/TestOnlyInfiniteLoopsMain.java: Nested irreducible loops, where the inner loop floats out of the outer
compiler/loopopts/TestOptimizeFillWithStripMinedLoop.java: assert(use == polladr) failed: the use should be a safepoint polling
compiler/loopopts/TestOverunrolling.java: Tests correct dominator information after over-unrolling a loop.
compiler/loopopts/TestPartialPeelAtUnsignedTests.java: Tests partial peeling at unsigned tests.
compiler/loopopts/TestPartialPeelingSinkNodes.java: Sinking of nodes in partial peeling creates too many clones resulting in a live node limit exceeded assertion failure.
compiler/loopopts/TestPeelingNeverEnteredLoop.java: C2: assert(cl->trip_count() > 0) failed: peeling a fully unrolled loop
compiler/loopopts/TestPhaseCFGNeverBranchToGotoMain.java#id0: Peeling of Irreducible loop can lead to NeverBranch being visited from either side
compiler/loopopts/TestPhaseCFGNeverBranchToGotoMain.java#id1: Peeling of Irreducible loop can lead to NeverBranch being visited from either side
compiler/loopopts/TestPhiInSkeletonPredicateExpression.java: Assertion in PhaseIdealLoop::skeleton_predicate_has_opaque after JDK-8289127
compiler/loopopts/TestPreMainPostFallInEdges.java: Tests the rewiring and cloning of fall-in values from the main loop (and pre loop) to the post (and main loop) which resulted in a DUIterator_Fast assertion failure due to an insertion in the outputs of the loop header node.
compiler/loopopts/TestPredicateInputBelowLoopPredicate.java: C2: assert(false) failed: cyclic dependency prevents range check elimination
compiler/loopopts/TestRCEAfterUnrolling.java: SIGILL in C2 generated OSR compilation.
compiler/loopopts/TestRemixAddressExpressionsWithIrreducibleLoop.java: Test handling of irreducible loops in PhaseIdealLoop::remix_address_expressions.
compiler/loopopts/TestRemoveEmptyLoop.java: Unexpected test result caused by C2 IdealLoopTree::do_remove_empty_loop
compiler/loopopts/TestRemoveMainPostLoops.java: Verify that correct loops are selected when trying to remove main/post.
compiler/loopopts/TestSinkingMoreThan2AddPNodes.java: C2: assert(u->find_out_with(Op_AddP) == nullptr) failed: more than 2 chained AddP nodes?
compiler/loopopts/TestSinkingNodesCausesLongCompilation.java: Massive (up to ~30x) increase in C2 compilation time since JDK 17
compiler/loopopts/TestSkeletonPredicateNegation.java: Skeleton predicates sometimes need to be negated
compiler/loopopts/TestSplitIfBlocksDisabled.java: Verifies that loop optimizations work if SplitIfBlocks is disabled.
compiler/loopopts/TestSplitIfOpaque1.java: The split-if optimization fails because an unexpected Opaque1 is encountered.
compiler/loopopts/TestSplitIfPinnedCMove.java: too strong assert from 8186125
compiler/loopopts/TestSplitIfPinnedLoadInStripMinedLoop.java: A LoadNode is pinned in split_if_with_blocks_post() on a loop exit node x that is part of a strip mined loop.
compiler/loopopts/TestSplitIfUnswitchedLoopsEliminated.java: split if finds predicates on several incoming paths when unswitched's loops are optimized out
compiler/loopopts/TestSplitThruPhiDivMod.java: A Division/modulo node whose zero check was removed is split through an induction variable phi and executed before the loop limit check resulting in a SIGFPE because the divisor is zero.
compiler/loopopts/TestStoreSunkInInnerLoop.java: C2 fails with assert(!n->is_Store() && !n->is_LoadStore()) failed: no node with a side effect
compiler/loopopts/TestStrangeControl.java: Test PhaseIdealLoop::has_local_phi_input() with phi input with non-dominating control.
compiler/loopopts/TestStripMinedBackToBackIfs.java: Bad graph when unrolled loop bounds conflicts with range checks
compiler/loopopts/TestSunkCastOnUnreachablePath.java: C2: assert(false) failed: Bad graph detected in build_loop_late
compiler/loopopts/TestSunkNodeDueToBrokenAntiDependency.java: C2: assert(false) failed: graph should be schedulable after JDK-8252372
compiler/loopopts/TestSunkNodeMissingCastAssert.java: assert(cast != nullptr) failed: must have added a cast to pin the node
compiler/loopopts/TestUndetectedLoopInInfiniteLoop.java: Loops inside infinite loops may not be detected, thus a region may still be the loop head, even if it is not a LoopNode.
compiler/loopopts/TestUnrollLimitPreciseType.java#test1: CMoveI for underflow protection of the limit did not compute a type that was precise enough.
compiler/loopopts/TestUnrollLimitPreciseType.java#test2: CMoveI for underflow protection of the limit did not compute a type that was precise enough.
compiler/loopopts/TestUnswitchCloneSkeletonPredicates.java: Test the complete cloning of skeleton predicates to unswitched loops as done when cloning them to the main loop.
compiler/loopopts/TestUnswitchOverunrolling.java: Test different cases of overunrolling the main loop of unswitched loops (pre/main/post) which are then not entered.
compiler/loopopts/TestUnswitchWithSunkNodes.java: A pinned Cast node on the UCT projection of a predicate is as input for the UCT phi node for the original loop, the fast and slow loop resulting in a dominance failure.
compiler/loopopts/TestWrongCMovSplitIf.java: C2: "Bad graph detected in build_loop_late" after a CMove is wrongly split thru phi
compiler/loopopts/TestWrongOffsetConstantArrayConstant.java: Phi of AddP transformation can cause offset in constant array to be dropped
compiler/loopopts/superword/AlignmentOnePack.java: Tests the case where there is only 1 pack and no operations left when calling SuperWord::find_align_to_ref() to find the best alignment again.
compiler/loopopts/superword/CoLocatePack.java: Tests SuperWord::co_locate_pack() involving a load pack that relies on a sandwiched and moved StoreF node.
compiler/loopopts/superword/CoLocatePackMemoryState.java: Tests to select the memory state of the last load in a load pack in SuperWord::co_locate_pack.
compiler/loopopts/superword/ProdRed_Double.java: Add C2 x86 Superword support for scalar product reduction optimizations : float test
compiler/loopopts/superword/ProdRed_Float.java: Add C2 x86 Superword support for scalar product reduction optimizations : float test
compiler/loopopts/superword/ProdRed_Int.java: Add C2 x86 Superword support for scalar product reduction optimizations : int test
compiler/loopopts/superword/RedTest_int.java: Add C2 x86 Superword support for scalar logical reduction optimizations : int test
compiler/loopopts/superword/RedTest_long.java: Add C2 x86 Superword support for scalar logical reduction optimizations : long test
compiler/loopopts/superword/ReductionPerf.java: Add C2 x86 Superword support for scalar product reduction optimizations : int test
compiler/loopopts/superword/SumRedSqrt_Double.java: Add C2 x86 Superword support for scalar sum reduction optimizations : double sqrt test
compiler/loopopts/superword/SumRed_Double.java: Add C2 x86 Superword support for scalar sum reduction optimizations : double test
compiler/loopopts/superword/SumRed_Float.java: Add C2 x86 Superword support for scalar sum reduction optimizations : float test
compiler/loopopts/superword/SumRed_Int.java: Add C2 x86 Superword support for scalar sum reduction optimizations : int test
compiler/loopopts/superword/SumRed_Long.java: Add C2 x86 Superword support for scalar sum reduction optimizations : long test
compiler/loopopts/superword/SuperWordIntermediateUse.java: The IR of this test contains a reduction chain which corresponds to a pack in which the 2nd last element has a usage outside of the optimized loop.
compiler/loopopts/superword/TestBestAlign.java: Limit calculation of pre loop during super word optimization is wrong
compiler/loopopts/superword/TestEliminateAllocationWithCastP2XUse.java: Test SuperWord, when it aligns to field-store, and the corresponding allocation is eliminated.
compiler/loopopts/superword/TestFuzzPreLoop.java: SEGV in SuperWord::get_pre_loop_end
compiler/loopopts/superword/TestHoistedReductionNode.java: Test that inconsistent reduction node-loop state does not trigger assertion failures when the inconsistency does not lead to a miscompilation.
compiler/loopopts/superword/TestMovingLoadBeforeStore.java: In SuperWord::output, LoadVector can be moved before StoreVector, but only if it is proven to be safe.
compiler/loopopts/superword/TestNegBaseOffset.java: Test skipping vector packs with negative base offset.
compiler/loopopts/superword/TestPeeledReductionNode.java: Test that reduction nodes peeled out of an inner loop are not vectorized as reductions within the outer loop.
compiler/loopopts/superword/TestPickFirstMemoryState.java: Test which needs to select the memory state of the first load in a load pack in SuperWord::co_locate_pack.
compiler/loopopts/superword/TestReductionWithLoopVariantUse.java: Loop variant use in reduction should prevent vectorization
compiler/loopopts/superword/TestSearchAlignment.java: JVM crash in SWPointer during C2 compilation
compiler/loopopts/superword/TestVectorizationWithInvariant.java: Tests correct alignment of vectors with loop invariant offset.
compiler/loopopts/superword/TestWronglyMarkedReduction.java: Cloned node in AddNode::Ideal is no longer a reduction but is still marked as such leading to wrong vectorization.
compiler/loopopts/superword/Vec_MulAddS2I.java: Test operations in C2 MulAddS2I and MulAddVS2VI nodes.
compiler/loopstripmining/AntiDependentLoadInOuterStripMinedLoop.java: Sinking load out of loop may trigger: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/BackedgeNodeWithOutOfLoopControl.java: "node not on backedge" assert in OuterStripMinedLoopNode::adjust_strip_mined_loop
compiler/loopstripmining/CheckLoopStripMining.java: C2: LoopStripMining doesn't strip as expected
compiler/loopstripmining/CheckLoopStripMiningIterShortLoop.java: when loop strip is enabled, LoopStripMiningIterShortLoop should be not null
compiler/loopstripmining/DeadNodesInOuterLoopAtLoopCloning.java: loop unrolling breaks when outer strip mined loop contains dead node
compiler/loopstripmining/DeadNodesInOuterLoopAtLoopCloning2.java: loop unrolling breaks when outer strip mined loop contains dead node
compiler/loopstripmining/LimitSharedwithOutOfLoopTest.java: limit test is shared with out of loop if
compiler/loopstripmining/LoadDependsOnIfIdenticalToLoopExit.java: shared an identical bool node with a strip-mined loop
compiler/loopstripmining/LoadSplitThruPhi.java: ShouldNotReachHere in PhaseIdealLoop::verify_strip_mined_scheduling
compiler/loopstripmining/OuterStripMinedLoopLoadWronglyHoisted.java: C2 compilation fails with assert "n is later than its clone"
compiler/loopstripmining/StripMinedLoopReorgOffsets.java: C2 still crashes with "assert(mode == ControlAroundStripMined && use == sfpt) failed: missed a node"
compiler/loopstripmining/TestAddPAtOuterLoopHead.java: C2: assert(get_ctrl(n) == cle_out) during unrolling
compiler/loopstripmining/TestCastIIAfterUnrollingInOuterLoop.java: C2: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/TestConservativeAntiDep.java: C2: ShouldNotReachHere() in verify_strip_mined_scheduling
compiler/loopstripmining/TestDeadOuterStripMinedLoop.java: Test loop strip mining verification with dying outer loop.
compiler/loopstripmining/TestEliminatedLoadPinnedOnBackedge.java: C2: "failed: only phis" assert failure in loop strip mining verfication
compiler/loopstripmining/TestLSMBadControlOverride.java: Segfault at PhaseIdealLoop::clone_loop_handle_data_uses
compiler/loopstripmining/TestLoadOnBackedgeWithPrec.java: Loop strip mining verification fails with "should be on the backedge"
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Epsilon: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#G1: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Shenandoah: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Z: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestOuterStripMinedDeadAfterExpansion.java: dead outer strip mined not optimized out after expansion
compiler/loopstripmining/TestPinnedNodeInInnerLoop.java: C2: assert(!loop->is_member(u_loop)) failed: can be in outer loop or out of both loops only
compiler/loopstripmining/TestPinnedUseInOuterLSMUnusedBySfpt.java: C2 compilation fails with assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/TestStoreSunkToOuterLoop.java: assert(outer->outcnt() == 2) failed: 'only phis' failure in LoopNode::verify_strip_mined()
compiler/loopstripmining/TestStripMinedLimitBelowInit.java: Following 8241492, strip mined loop may run extra iterations
compiler/loopstripmining/TestUseFromInnerInOuterUnusedBySfpt.java: C2 compilation hits "assert((mode == ControlAroundStripMined && use == sfpt) || !use->is_reachable_from_root()) failed: missed a node"
compiler/loopstripmining/UnexpectedNodeInOuterLoopWhenCloning.java: C2: assert(mode == ControlAroundStripMined && use == sfpt) failed: missed a node
compiler/loopstripmining/UnexpectedPinnedNodeInOuterLoop.java: C2: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/macronodes/TestCompleteVolatileStore.java: Tests proper rehashing of a captured volatile field StoreL node when completing it.
compiler/macronodes/TestEliminateAllocationPhi.java: PhiNode inserted between AllocateNode and Initialization node confuses allocation elimination
compiler/membars/TestMemBarAcquire.java: Tests optimization of MemBarAcquireNodes
compiler/memoryinitialization/ZeroTLABTest.java:
compiler/onSpinWait/TestOnSpinWait.java: (x86 only) checks that java.lang.Thread.onSpinWait is intrinsified
compiler/onSpinWait/TestOnSpinWaitC1.java: (x86 only) checks that java.lang.Thread.onSpinWait is intrinsified
compiler/onSpinWait/TestOnSpinWaitEnableDisable.java: Test to ensure basic functioning of java.lang.Thread.onSpinWait
compiler/osr/TestOSRWithNonEmptyStack.java: Force OSR compilation with non-empty stack at the OSR entry point.
compiler/osr/TestRangeCheck.java: Tests that range check is not skipped
compiler/parsing/TestExceptionBlockWithPredecessorsMain.java: Tests custom bytecode with an explicit entry (fall through or jump) to an exception block which was unexpected for C2 parsing.
compiler/parsing/TestMissingSafepointOnSwitch.java: C2: "malformed control flow" assert due to missing safepoint on backedge with a switch
compiler/parsing/TestMissingSafepointOnTryCatch.java: assert(false) failed: malformed control flow to missing safepoint on backedge of a try-catch
compiler/parsing/UnreachableBlockFallsThroughEndOfCode.java: Compiling method that falls off the end of the code array
compiler/profiling/TestMethodHandleInvokesIntrinsic.java: profiling of arguments in C1 at MethodHandle invoke of intrinsic tries to profile popped argument.
compiler/profiling/TestMultiBranchDataOverflow.java: Test int range overflow of MultiBranchData counter.
compiler/profiling/TestProfileCounterOverflow.java: Profile counter for a call site may overflow.
compiler/profiling/TestSpecTrapClassUnloading.java: speculative traps need to be cleaned up at GC
compiler/profiling/TestTypeProfiling.java: Parameters type profiling is not performed from aarch64 interpreter
compiler/profiling/TestUnexpectedProfilingMismatch.java: profiling of arguments at calls cannot rely on signature of callee for types
compiler/profiling/UnsafeAccess.java:
compiler/profiling/spectrapredefineclass/Launcher.java:
compiler/profiling/spectrapredefineclass_classloaders/Launcher.java:
compiler/profiling/unloadingconflict/TestProfileConflictClassUnloading.java: class unloading resets profile, method compiled after the profile is first set and before class loading sets unknown bit with not recorded class
compiler/rangechecks/PowerOf2SizedArraysChecks.java: strength reduce or eliminate range checks for power-of-two sized arrays
compiler/rangechecks/RangeCheckEliminationScaleNotOne.java: C2: range check elimination may allow illegal out of bound access
compiler/rangechecks/TestBadFoldCompare.java: x <= 0 || x > 0 wrongly folded as (x-1) >u -1 and x < 0 || x > -1 wrongly folded as x >u -1
compiler/rangechecks/TestExplicitRangeChecks.java: explicit range checks should be recognized by C2
compiler/rangechecks/TestRangeCheckCmpUOverflowVsSub.java: In CmpU::Value, the sub computation may be narrower than the overflow computation.
compiler/rangechecks/TestRangeCheckCmpUUnderflow.java: Dominator failure because ConvL2I node becomes TOP, kills data-flow, but range-check does not collapse due to insufficient overflow/underflow handling in CmpUNode::Value.
compiler/rangechecks/TestRangeCheckEliminationDisabled.java: Tests PostLoopMultiversioning with RangeCheckElimination disabled.
compiler/rangechecks/TestRangeCheckExceptionHandlerLoopMain.java: C1's range check elimination breaks with a non-natural loop that an exception handler as one entry
compiler/rangechecks/TestRangeCheckLimits.java: Dominator failure because ConvL2I node becomes TOP due to missing overflow/underflow handling in range check elimination in PhaseIdealLoop::add_constraint().
compiler/rangechecks/TestRangeCheckSmearing.java: C2's range check smearing allows out of bound array accesses
compiler/rangechecks/TestRangeCheckSmearingLoopOpts.java: Following range check smearing, range check cannot be replaced by dominating identical test.
compiler/rangechecks/TestSunkRangeFromPreLoopRCE.java: C2: "node pinned on loop exit test?" assert failure
compiler/rangechecks/TestUncommonTrapMerging.java: Verify proper re-execution of checks after merging of uncommon traps
compiler/reflection/ArrayNewInstanceOfVoid.java: ShouldNotReachHere error when creating an array with component type of void
compiler/regalloc/C1ObjectSpillInLogicOp.java: C1 crashes generating G1 post-barrier in Unsafe.getAndSetReference() intrinsic because of the new value spill
compiler/regalloc/TestC1OverlappingRegisterHint.java: The C1 register allocator uses a register hint interval i as spill location for an interval j which overlaps with one of i's split children which has the same spill location which lets verification fail.
compiler/regalloc/TestGCMRecalcPressureNodes.java: crash in PhaseCFG::global_code_motion
compiler/regalloc/TestNodeRegArrayOverflow.java: Test that C2's PhaseRegAlloc::_node_regs (a post-register-allocation mapping from machine nodes to assigned registers) does not overflow in the face of a program with a high-density of CISC spilling candidate nodes.
compiler/regalloc/TestVectorRegAlloc.java: assert in register allocation code when vector Phi for a loop is processed because code assumes all inputs already processed
compiler/regalloc/VolatileLoadMemBarsOnlyUses.java: C2: assert(n->outcnt() != 0 || C->top() == n || n->is_Proj()) failed: No dead instructions after post-alloc
compiler/rtm/cli/TestPrintPreciseRTMLockingStatisticsOptionOnUnsupportedConfig.java: Verify PrintPreciseRTMLockingStatistics on CPUs or OSs without rtm support and/or unsupported VM.
compiler/rtm/cli/TestRTMAbortThresholdOption.java: Verify processing of RTMAbortThreshold option.
compiler/rtm/cli/TestRTMLockingCalculationDelayOption.java: Verify processing of RTMLockingCalculationDelay option.
compiler/rtm/cli/TestRTMLockingThresholdOption.java: Verify processing of RTMLockingThreshold option.
compiler/rtm/cli/TestRTMRetryCountOption.java: Verify processing of RTMRetryCount option.
compiler/rtm/cli/TestRTMSpinLoopCountOption.java: Verify processing of RTMSpinLoopCount option.
compiler/rtm/cli/TestUseRTMDeoptOptionOnUnsupportedConfig.java: Verify UseRTMDeopt option processing on CPUs or OSs without rtm support or on VMs without rtm locking support.
compiler/rtm/cli/TestUseRTMForStackLocksOptionOnUnsupportedConfig.java: Verify UseRTMForStackLocks option processing on CPUs or OSs without rtm support and/or on VMs without rtm locking support.
compiler/rtm/cli/TestUseRTMLockingOptionOnUnsupportedCPU.java: Verify UseRTMLocking option processing on CPUs without rtm support.
compiler/rtm/cli/TestUseRTMXendForLockBusyOption.java: Verify processing of UseRTMXendForLockBusy option.
compiler/runtime/JITClassInit.java: self-parser test causes JDK 1.2 Beta4K segmentation fault
compiler/runtime/SpreadNullArg.java: verifies that the MethodHandle spread adapter can gracefully handle null arguments.
compiler/runtime/StackOverflowBug.java: JVM crashes with "missing exception handler" error
compiler/runtime/Test6778657.java: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
compiler/runtime/Test6826736.java: CMS: core dump with -XX:+UseCompressedOops
compiler/runtime/Test6859338.java: Assertion failure in sharedRuntime.cpp
compiler/runtime/Test6863420.java: os::javaTimeNanos() go backward on Solaris x86
compiler/runtime/Test6892265.java: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
compiler/runtime/Test7088020.java: SEGV in JNIHandleBlock::release_block
compiler/runtime/Test7196199.java: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
compiler/runtime/Test8010927.java: Kitchensink crashed with SIGSEGV, Problematic frame: v ~StubRoutines::checkcast_arraycopy
compiler/runtime/TestConstantsInError.java:
compiler/runtime/TestFloatsOnStackDeopt.java: testing deoptimization on safepoint with floating point values on stack
compiler/runtime/cr6891750/Test6891750.java: deopt blob kills values in O5
compiler/runtime/cr8015436/Test8015436.java: the IK _initial_method_idnum value must be adjusted if overpass methods are added
compiler/runtime/criticalnatives/argumentcorruption/CheckLongArgs.java:
compiler/runtime/criticalnatives/lookup/LookUp.java:
compiler/runtime/safepoints/TestRegisterRestoring.java: Test correct saving and restoring of vector registers at safepoints.
compiler/runtime/unloaded/TestMHUnloaded.java:
compiler/stable/TestStableBoolean.java: tests on stable fields and arrays
compiler/stable/TestStableByte.java: tests on stable fields and arrays
compiler/stable/TestStableChar.java: tests on stable fields and arrays
compiler/stable/TestStableDouble.java: tests on stable fields and arrays
compiler/stable/TestStableFloat.java: tests on stable fields and arrays
compiler/stable/TestStableInt.java: tests on stable fields and arrays
compiler/stable/TestStableLong.java: tests on stable fields and arrays
compiler/stable/TestStableMemoryBarrier.java: tests memory barrier correctly inserted for stable fields
compiler/stable/TestStableMismatched.java: Tests if mismatched char load from stable byte[] returns correct result
compiler/stable/TestStableObject.java: tests on stable fields and arrays
compiler/stable/TestStableShort.java: tests on stable fields and arrays
compiler/stable/TestStableUByte.java: tests on stable fields and arrays
compiler/stable/TestStableUShort.java: tests on stable fields and arrays
compiler/startup/NumCompilerThreadsCheck.java: Ensures correct minimal number of compiler threads (provided by -XX:CICompilerCount=)
compiler/startup/SmallCodeCacheStartup.java: Test ensures that there is no crash if there is not enough ReservedCodeCacheSize to initialize all compiler threads.
compiler/startup/StartupOutput.java: Test ensures correct VM output during startup
compiler/startup/TieredStopAtLevel0SanityTest.java: Sanity test flag combo that force compiles on level 0
compiler/stringopts/TestLongStringConcat.java: Test very long chain of StringBuilder append calls.
compiler/stringopts/TestOptimizeStringConcat.java: test that string optimizations produce code, that doesn't lead to a crash.
compiler/stringopts/TestSideEffectBeforeConstructor.java: Test correctness of the string concatenation optimization with a store between StringBuffer allocation and constructor invocation.
compiler/stringopts/TestStackedConcatsAppendUncommonTrap.java: Test stacked string concatenations where the toString result of the first StringBuilder chain is wired into an uncommon trap located in the second one.
compiler/stringopts/TestStringObjectInitialization.java: Verifies that no partially initialized String object escapes from C2's String concat optimization in a highly concurrent setting.
compiler/types/TestArrayMeetNotSymmetrical.java: Meet not symmetric failure when running lucene on jdk8
compiler/types/TestFoldNECompares.java: Test folding of != integer comparisons.
compiler/types/TestIntArraySubTypeOfCloneableDoesnotFold.java: C2: assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization
compiler/types/TestInterfaceArraySubtypeCheck.java: C2 incorrectly folds subtype checks involving an interface array.
compiler/types/TestMeetExactConstantArrays.java: meet of 2 constant arrays result in bottom
compiler/types/TestMeetIncompatibleInterfaceArrays.java: C2 can not handle returns with inccompatible interface arrays
compiler/types/TestMeetTopArrayExactConstantArray.java: meet of TopPTR exact array with constant array is not symmetric
compiler/types/TestMeetXor.java: Test meet on xor
compiler/types/TestMethodHandleSpeculation.java: Crash/miscompile in CallGenerator::for_method_handle_inline after JDK-8191998
compiler/types/TestPhiElimination.java: Tests elimination of Phi nodes without losing type information.
compiler/types/TestSpeculationFailedHigherEqual.java: type methods shouldn't always operate on speculative part
compiler/types/TestSubTypeCheckMacroNodeWrongMem.java: Wiring of memory in SubTypeCheck macro node causes graph should be schedulable
compiler/types/TestSubTypeCheckMacroTrichotomy.java: clazz.isAssignableFrom will return false for interface implementors
compiler/types/TestSubTypeCheckNewObjectNotConstant.java: C2: "assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization" still happens after fix for 8239335
compiler/types/TestSubTypeOfAsbtractClassWrongResult.java: subtype check with abstract class that has no children classes can sometimes be constant folded
compiler/types/TestTypePropagationToCmpU.java: Test correctness of type propagation to CmpUNodes.
compiler/types/TypeSpeculation.java: Test that type speculation doesn't cause incorrect execution
compiler/types/correctness/CorrectnessTest.java: Tests correctness of type usage with type profiling and speculations
compiler/types/correctness/OffTest.java:
compiler/uncommontrap/DeoptReallocFailure.java:
compiler/uncommontrap/FoldedIfNonDomMidIf.java: IfNode::fold_compares() may lead to incorrect execution
compiler/uncommontrap/StackOverflowGuardPagesOff.java: stack overflow if callee is marked for deoptimization causes crash
compiler/uncommontrap/Test8009761.java: Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates
compiler/uncommontrap/TestDeoptOOM.java#id0: failed reallocations of scalar replaced objects during deoptimization causes crash
compiler/uncommontrap/TestDeoptOOM.java#id1: Test that ttyLock isn't held when taking StackWatermark_lock
compiler/uncommontrap/TestLockEliminatedAtDeopt.java: biased locking's revoke_bias locks monitor in compiled frame with eliminated lock
compiler/uncommontrap/TestNullAssertAtCheckCast.java: Test that failing checkcast does not trigger repeated recompilation until cutoff is hit.
compiler/uncommontrap/TestNullCheckAntiDependence.java: Test that no anti-dependence violation is reported between a store used as an implicit null check and a load placed in the null block.
compiler/uncommontrap/TestStackBangMonitorOwned.java: Stack overflow at deoptimization doesn't release owned monitors
compiler/uncommontrap/TestStackBangRbp.java: rbp not restored when stack overflow is thrown from deopt/uncommon trap blobs
compiler/uncommontrap/TestUnstableIfTrap.java:
compiler/uncommontrap/TraceDeoptimizationNoRealloc.java: -XX:+TraceDeoptimization tries to print realloc'ed objects even when there are none
compiler/uncommontrap/UncommonTrapLeak.java: Handle leak might cause object not collected as expected
compiler/uncommontrap/UncommonTrapStackBang.java: Uncommon trap blob did not bang all the stack shadow pages
compiler/unsafe/AlignmentGapAccess.java:
compiler/unsafe/CASandCAEwithNegExpected.java: Aarch64: unsafe.compareAndSetByte() and unsafe.compareAndSetShort() c2 intrinsics broken with negative expected value
compiler/unsafe/GetUnsafeObjectG1PreBarrier.java: The bug only happens with C1 and G1 using a different ObjectAlignmentInBytes than KlassAlignmentInBytes (which is 8)
compiler/unsafe/JdkInternalMiscUnsafeAccessTestBoolean.java: Test unsafe access for boolean
compiler/unsafe/JdkInternalMiscUnsafeAccessTestByte.java: Test unsafe access for byte
compiler/unsafe/JdkInternalMiscUnsafeAccessTestChar.java: Test unsafe access for char
compiler/unsafe/JdkInternalMiscUnsafeAccessTestDouble.java: Test unsafe access for double
compiler/unsafe/JdkInternalMiscUnsafeAccessTestFloat.java: Test unsafe access for float
compiler/unsafe/JdkInternalMiscUnsafeAccessTestInt.java: Test unsafe access for int
compiler/unsafe/JdkInternalMiscUnsafeAccessTestLong.java: Test unsafe access for long
compiler/unsafe/JdkInternalMiscUnsafeAccessTestObject.java: Test unsafe access for Object
compiler/unsafe/JdkInternalMiscUnsafeAccessTestShort.java: Test unsafe access for short
compiler/unsafe/JdkInternalMiscUnsafeUnalignedAccess.java: Test unaligned Unsafe accesses
compiler/unsafe/MaybeOffHeapUnsafeAccessToNewObject.java: "failed: unexpected type" assert failure in ConnectionGraph::split_unique_types() with unsafe accesses
compiler/unsafe/MisalignedAccesses.java: Crash on aarch64 JDK due to long offset
compiler/unsafe/MismatchedUnsafeAccessTest.java:
compiler/unsafe/MismatchedUnsafeLoadFromNewObject.java: Mismatched unsafe access to non escaping object fails
compiler/unsafe/MixedUnsafeStoreObject.java:
compiler/unsafe/OpaqueAccesses.java:
compiler/unsafe/SunMiscUnsafeAccessTestBoolean.java: Test unsafe access for boolean
compiler/unsafe/SunMiscUnsafeAccessTestByte.java: Test unsafe access for byte
compiler/unsafe/SunMiscUnsafeAccessTestChar.java: Test unsafe access for char
compiler/unsafe/SunMiscUnsafeAccessTestDouble.java: Test unsafe access for double
compiler/unsafe/SunMiscUnsafeAccessTestFloat.java: Test unsafe access for float
compiler/unsafe/SunMiscUnsafeAccessTestInt.java: Test unsafe access for int
compiler/unsafe/SunMiscUnsafeAccessTestLong.java: Test unsafe access for long
compiler/unsafe/SunMiscUnsafeAccessTestObject.java: Test unsafe access for Object
compiler/unsafe/SunMiscUnsafeAccessTestShort.java: Test unsafe access for short
compiler/unsafe/TestBadBaseAddress.java: Tests compilation of an unreachable unsafe access with a bad base address.
compiler/unsafe/TestLoopUnswitching.java: loop cloning misses support for Opaque4 node
compiler/unsafe/TestMaybeNullUnsafeAccess.java: cast before unsafe access moved in dominating null check null path causes crash
compiler/unsafe/TestMisalignedUnsafeAccess.java: "assert(field != __null) failed: missing field" in TypeOopPtr::TypeOopPt(...) with misaligned unsafe accesses
compiler/unsafe/TestRawAliasing.java:
compiler/unsafe/TestSplitIf.java: cast before unsafe access moved in dominating null check null path causes crash
compiler/unsafe/TestUnsafeLoadControl.java: Unsafe load can loose control dependency and cause crash
compiler/unsafe/TestUnsafeLoadWithZeroAddress.java: Test compilation of unsafe access with zero address.
compiler/unsafe/TestUnsafeStaticFieldAccess.java: unsafe access to static field causes crash
compiler/unsafe/UnsafeGetConstantField.java: tests on constant folding of unsafe get operations
compiler/unsafe/UnsafeGetStableArrayElement.java: tests on constant folding of unsafe get operations from stable arrays
compiler/unsafe/UnsafeOffHeapBooleanTest.java:
compiler/unsafe/UnsafeOnHeapBooleanTest.java:
compiler/unsafe/UnsafeRaw.java: Invalid pattern-matching of address computations in raw unsafe
compiler/unsafe/UnsafeSmallOffsetBooleanAccessTest.java:
compiler/vectorization/TestAbsCharVector.java: Test vectorization of Math.abs() with unsigned type
compiler/vectorization/TestComplexAddrExpr.java: Test vectorization for complex address expressions
compiler/vectorization/TestForEachRem.java: Test vectorization of Streams$RangeIntSpliterator::forEachRemaining
compiler/vectorization/TestMacroLogicVector.java:
compiler/vectorization/TestMaskedVectors.java: Test masked vectors and unsafe access to memory modified by arraycopy
compiler/vectorization/TestMemoryVectorMismatched.java:
compiler/vectorization/TestNaNVector.java: Test vectorization with a signalling NaN.
compiler/vectorization/TestOptionVectorize.java: Test forced vectorization
compiler/vectorization/TestPopCountVector.java: Test vectorization of popcount
compiler/vectorization/TestUnexpectedLoadOrdering.java: RPO walk of counted loop block doesn't properly order loads
compiler/vectorization/TestVectorUnalignedOffset.java: Aarch64: vector nodes need to support misaligned offset
compiler/vectorization/TestVectorsNotSavedAtSafepoint.java: C2: Vector registers are sometimes corrupted at safepoint
gc/ArraySize.java: Allocating a ridiculously large array should not crash the VM
gc/CondCardMark/Basic.java: Verify UseCondCardMark works
gc/CriticalNativeArgs.java#id0: test argument unpacking nmethod wrapper of critical native method
gc/CriticalNativeArgs.java#id2: test argument unpacking nmethod wrapper of critical native method
gc/InfiniteList.java: Check if the VM properly throws OutOfMemoryError
gc/TestAgeOutput.java#id0:
gc/TestAgeOutput.java#id1: Check that collectors using age table based aging print an age table even for the first garbage collection
gc/TestAllocateHeapAt.java: Test to check allocation of Java Heap with AllocateHeapAt option
gc/TestAllocateHeapAtError.java: Test to check correct handling of non-existent directory passed to AllocateHeapAt option
gc/TestAllocateHeapAtMultiple.java: Test to check allocation of Java Heap with AllocateHeapAt option.
gc/TestBigObj.java: ensure gc updates references > 64K bytes from the start of the obj
gc/TestCardTablePageCommits.java: Tests that the card table does not commit the same page twice
gc/TestConcurrentGCBreakpoints.java: Test of WhiteBox concurrent GC control.
gc/TestDisableExplicitGC.java: Verify GC behavior with DisableExplicitGC flag.
gc/TestFullGCCount.java: JMM GC counters overcount in some cases
gc/TestGenerationPerfCounter.java#id0: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestGenerationPerfCounter.java#id1: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestGenerationPerfCounter.java#id2: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestHumongousReferenceObject.java#id0: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries, with references in them works.
gc/TestHumongousReferenceObject.java#id1: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries on G1, with references in them works.
gc/TestHumongousReferenceObject.java#id2: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries, with references in them works.
gc/TestJNIWeak/TestJNIWeak.java: Test return of JNI weak global refs during concurrent marking, verifying the use of the load barrier to keep the referent alive.
gc/TestMemoryMXBeansAndPoolsPresence.java#id0: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestMemoryMXBeansAndPoolsPresence.java#id1: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestMemoryMXBeansAndPoolsPresence.java#id2: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestNUMAPageSize.java: Make sure that start up with NUMA support does not cause problems.
gc/TestNoPerfCounter.java: Tests that disabling perf counters does not crash the VM
gc/TestNumWorkerOutput.java: Check that when PrintGCDetails is enabled, gc,task output is printed only once per collection.
gc/TestObjectAlignment.java: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
gc/TestPolicyNamePerfCounter.java#id0: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestPolicyNamePerfCounter.java#id1: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestPolicyNamePerfCounter.java#id2: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestReferenceClearDuringMarking.java:
gc/TestReferenceRefersTo.java:
gc/TestReferenceRefersToDuringConcMark.java:
gc/TestSmallHeap.java: Verify that starting the VM with a small heap works
gc/TestSoftReferencesBehaviorOnOOME.java: Tests that all SoftReferences has been cleared at time of OOM.
gc/TestSpaceCounters.java#Parallel: Verify the expected space counters exist.
gc/TestSpaceCounters.java#Serial: Verify the expected space counters exist.
gc/TestStackOverflow.java: Test verifies only that VM doesn't crash but throw expected Error.
gc/TestSystemGC.java#G1: Runs System.gc() with different flags.
gc/TestSystemGC.java#Parallel: Runs System.gc() with different flags.
gc/TestSystemGC.java#Serial: Runs System.gc() with different flags.
gc/TestSystemGC.java#Shenandoah: Runs System.gc() with different flags.
gc/TestSystemGC.java#Z: Runs System.gc() with different flags.
gc/TestVerifyDuringStartup.java: Simple test run with -XX:+VerifyDuringStartup -XX:-UseTLAB to verify 8010463
gc/TestVerifySilently.java: Test silent verification.
gc/TestVerifySubSet.java: Test VerifySubSet option
gc/arguments/TestAggressiveHeap.java: Test argument processing for -XX:+AggressiveHeap.
gc/arguments/TestAlignmentToUseLargePages.java#id0:
gc/arguments/TestAlignmentToUseLargePages.java#id1: All parallel GC variants may use large pages without the requirement that the heap alignment is large page aligned.
gc/arguments/TestAlignmentToUseLargePages.java#id2:
gc/arguments/TestAlignmentToUseLargePages.java#id3:
gc/arguments/TestArrayAllocatorMallocLimit.java: Sanity check that the ArrayAllocatorMallocLimit flag can be set.
gc/arguments/TestCompressedClassFlags.java: Tests that VM prints a warning when -XX:CompressedClassSpaceSize is used together with -XX:-UseCompressedClassPointers
gc/arguments/TestDisableDefaultGC.java: Test that the VM complains when the default GC is disabled and no other GC is specified
gc/arguments/TestDynMaxHeapFreeRatio.java: Verify that MaxHeapFreeRatio flag is manageable
gc/arguments/TestDynMinHeapFreeRatio.java: Verify that MinHeapFreeRatio flag is manageable
gc/arguments/TestG1ConcMarkStepDurationMillis.java: Tests argument processing for double type flag, G1ConcMarkStepDurationMillis
gc/arguments/TestG1ConcRefinementThreads.java: Tests argument processing for G1ConcRefinementThreads
gc/arguments/TestG1HeapRegionSize.java: Verify that the flag G1HeapRegionSize is updated properly
gc/arguments/TestG1HeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the G1 collector
gc/arguments/TestG1PercentageOptions.java: Test argument processing of various percentage options
gc/arguments/TestHeapFreeRatio.java: Test parsing of -Xminf and -Xmaxf
gc/arguments/TestInitialTenuringThreshold.java: Tests argument processing for initial tenuring threshold
gc/arguments/TestMaxMinHeapFreeRatioFlags.java: Verify that heap size changes according to max and min heap free ratios.
gc/arguments/TestMaxNewSize.java#id0: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxNewSize.java#id1: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxNewSize.java#id2: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxRAMFlags.java: Verify correct MaxHeapSize and UseCompressedOops when MaxRAM and MaxRAMPercentage are specified.
gc/arguments/TestMinAndInitialSurvivorRatioFlags.java: Verify that MinSurvivorRatio and InitialSurvivorRatio flags work
gc/arguments/TestMinInitialErgonomics.java: Test Parallel GC ergonomics decisions related to minimum and initial heap size.
gc/arguments/TestNewRatioFlag.java: Verify that heap devided among generations according to NewRatio
gc/arguments/TestNewSizeFlags.java: Verify that young gen size conforms values specified by NewSize, MaxNewSize and Xmn options
gc/arguments/TestNewSizeThreadIncrease.java: Tests argument processing for NewSizeThreadIncrease
gc/arguments/TestObjectTenuringFlags.java: Tests argument processing for NeverTenure, AlwaysTenure, and MaxTenuringThreshold
gc/arguments/TestParallelGCThreads.java: Tests argument processing for ParallelGCThreads
gc/arguments/TestParallelHeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the parallel collectors.
gc/arguments/TestParallelRefProc.java: Test defaults processing for -XX:+ParallelRefProcEnabled.
gc/arguments/TestSelectDefaultGC.java: Test selection of GC when no GC option is specified
gc/arguments/TestSerialHeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the Serial collector
gc/arguments/TestShrinkHeapInSteps.java: Verify that -XX:-ShrinkHeapInSteps works properly.
gc/arguments/TestSoftMaxHeapSizeFlag.java:
gc/arguments/TestSurvivorRatioFlag.java: Verify that actual survivor ratio is equal to specified SurvivorRatio value
gc/arguments/TestTargetSurvivorRatioFlag.java: Verify that option TargetSurvivorRatio affects survivor space occupancy after minor GC.
gc/arguments/TestUnrecognizedVMOptionsHandling.java: Tests handling unrecognized VM options
gc/arguments/TestUseCompressedOopsErgo.java#id0: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id1: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id2: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id3:
gc/arguments/TestUseNUMAInterleaving.java: Tests that UseNUMAInterleaving enabled for all collectors by ergonomics, on all platforms when UseNUMA feature is enabled.
gc/arguments/TestVerifyBeforeAndAfterGCFlags.java: Runs an simple application (GarbageProducer) with various combinations of -XX:{+|-}Verify{After|Before}GC flags and checks that output contain or doesn't contain expected patterns
gc/class_unloading/TestClassUnloadingDisabled.java#id0:
gc/class_unloading/TestClassUnloadingDisabled.java#id1:
gc/class_unloading/TestClassUnloadingDisabled.java#id2:
gc/class_unloading/TestClassUnloadingDisabled.java#id3:
gc/class_unloading/TestG1ClassUnloadingHWM.java: Test that -XX:-ClassUnloadingWithConcurrentMark will trigger a Full GC when more than MetaspaceSize metadata is allocated.
gc/cslocker/TestCSLocker.java: provoking GC.
gc/epsilon/TestAlignment.java#id0: Check Epsilon runs fine with (un)usual alignments
gc/epsilon/TestAlignment.java#id1: Check Epsilon TLAB options with unusual object alignment
gc/epsilon/TestAlwaysPretouch.java: Test that pre-touch works
gc/epsilon/TestArraycopyCheckcast.java: Epsilon is able to handle checkcasted array copies
gc/epsilon/TestByteArrays.java: Epsilon is able to allocate arrays, and does not corrupt their state
gc/epsilon/TestClasses.java: Epsilon is able to allocate a lot of classes, resizing Metaspace
gc/epsilon/TestDieDefault.java: Epsilon GC should die on heap exhaustion
gc/epsilon/TestDieWithHeapDump.java: Epsilon GC should die on heap exhaustion with error handler attached
gc/epsilon/TestDieWithOnError.java: Epsilon GC should die on heap exhaustion with error handler attached
gc/epsilon/TestElasticTLAB.java: Epsilon is able to work with/without elastic TLABs
gc/epsilon/TestElasticTLABDecay.java: Epsilon is able to work with/without elastic TLABs decay
gc/epsilon/TestEnoughUnusedSpace.java: Epsilon should allocates object successfully if it has enough space.
gc/epsilon/TestEpsilonEnabled.java: Basic sanity test for Epsilon
gc/epsilon/TestHelloWorld.java: Basic sanity test for Epsilon
gc/epsilon/TestLogTrace.java: Test that tracing does not crash Epsilon
gc/epsilon/TestManyThreads.java: Test allocations from many threads
gc/epsilon/TestMaxTLAB.java#id0: Check EpsilonMaxTLAB options
gc/epsilon/TestMaxTLAB.java#id1: Check EpsilonMaxTLAB options
gc/epsilon/TestMemoryPools.java: Test JMX memory pools
gc/epsilon/TestObjects.java: Epsilon is able to allocate objects, and does not corrupt their state
gc/epsilon/TestPrintHeapSteps.java: Tests -XX:EpsilonPrintHeapSteps works
gc/epsilon/TestRefArrays.java: Epsilon is able to allocate arrays, and does not corrupt their state
gc/epsilon/TestUpdateCountersSteps.java: Test EpsilonUpdateCountersStep works
gc/ergonomics/TestDynamicNumberOfGCThreads.java: Ensure that UseDynamicNumberOfGCThreads runs
gc/ergonomics/TestInitialGCThreadLogging.java: Check trace logging of initial GC threads.
gc/g1/Test2GbHeap.java: Regression test to ensure we can start G1 with 2gb heap.
gc/g1/TestBuffersToCardsOverflow.java:
gc/g1/TestConcurrentSystemGC.java: Test that a System.gc() with -XX:+ExplicitGCInvokesConcurrent is *not* upgraded to STW full GC
gc/g1/TestEagerReclaimHumongousRegions.java: Test to make sure that eager reclaim of humongous objects work.
gc/g1/TestEagerReclaimHumongousRegionsLog.java: Check that G1 reports humongous eager reclaim statistics correctly.
gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java: Test to make sure that eager reclaim of humongous objects that have previously been referenced by other old gen regions work.
gc/g1/TestEdenSurvivorLessThanMax.java: Check that G1 eden plus survivor max capacity after GC does not exceed maximum number of regions.
gc/g1/TestG1SkipCompaction.java: Test for JDK-8262068 Improve G1 Full GC by skipping compaction for regions with high survival ratio.
gc/g1/TestG1TraceEagerReclaimHumongousObjects.java: Ensure that the output for a G1TraceEagerReclaimHumongousObjects includes the expected necessary messages.
gc/g1/TestGCLogMessages.java: Ensure the output for a minor GC with G1 includes the expected necessary messages.
gc/g1/TestGreyReclaimedHumongousObjects.java: Test handling of marked but unscanned reclaimed humongous objects.
gc/g1/TestHumongousAllocConcurrentStart.java: G1: humongous object allocations should initiate marking cycles when necessary
gc/g1/TestHumongousAllocNearlyFullRegion.java: G1: humongous object allocations should work even when there is not enough space in the heapRegion to fit a filler object.
gc/g1/TestHumongousCodeCacheRoots.java: Humongous objects may have references from the code cache
gc/g1/TestHumongousConcurrentStartUndo.java: Tests an alternating sequence of Concurrent Mark and Concurrent Undo cycles.
gc/g1/TestHumongousRemsetsMatch.java: Test to make sure that humongous object remset states are in sync
gc/g1/TestHumongousShrinkHeap.java: Verify that heap shrinks after GC in the presence of fragmentation due to humongous objects
gc/g1/TestLargePageUseForAuxMemory.java: Test that auxiliary data structures are allocated using large pages if available.
gc/g1/TestLargePageUseForHeap.java: Test that Java heap is allocated using large pages of the appropriate size if available.
gc/g1/TestMarkStackSizes.java: Consistency checks for marking flag related options.
gc/g1/TestMixedGCLiveThreshold.java#0percent: Test G1MixedGCLiveThresholdPercent=0.
gc/g1/TestMixedGCLiveThreshold.java#100percent: Test G1MixedGCLiveThresholdPercent=100.
gc/g1/TestMixedGCLiveThreshold.java#25percent: Test G1MixedGCLiveThresholdPercent=25.
gc/g1/TestNoEagerReclaimOfHumongousRegions.java: Test to check that a live humongous object is not eagerly reclaimed.
gc/g1/TestNoUseHCC.java: Check that G1 survives a GC without HCC enabled
gc/g1/TestPLABOutput.java: Check that G1 does not report empty PLAB statistics in the first evacuation.
gc/g1/TestPLABSizeBounds.java: Regression test to ensure that G1 supports PLAB sizes of half a region size.
gc/g1/TestParallelAlwaysPreTouch.java: Regression test to ensure AlwaysPreTouch with multiple threads works at mutator time.
gc/g1/TestPeriodicCollection.java: Verify that heap shrinks when the application is idle.
gc/g1/TestPeriodicCollectionJNI.java: Test that issuing a periodic collection while the GC locker is held does not crash the VM.
gc/g1/TestPeriodicLogMessages.java: Verify that log messages are printed as expected
gc/g1/TestPrintRegionRememberedSetInfo.java: Test output of G1PrintRegionRememberedSetInfo
gc/g1/TestRegionAlignment.java: Make sure that G1 ergonomics pick a heap size that is aligned with the region size
gc/g1/TestRegionLivenessPrint.java: Make sure that G1 does not assert when printing region liveness data on a humongous continues region.
gc/g1/TestRemsetLogging.java: Verify output of -Xlog:gc+remset*=trace
gc/g1/TestRemsetLoggingPerRegion.java: Verify output of -Xlog:gc+remset*=trace in regards to per-region type output
gc/g1/TestRemsetLoggingThreads.java: Ensure that various values of worker threads/concurrent refinement threads do not crash the VM.
gc/g1/TestSharedArchiveWithPreTouch.java: Verifies that dumping and loading a CDS archive succeeds with AlwaysPreTouch
gc/g1/TestShrinkAuxiliaryData00.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
gc/g1/TestShrinkAuxiliaryData05.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
gc/g1/TestShrinkAuxiliaryData10.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
gc/g1/TestShrinkAuxiliaryData15.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
gc/g1/TestShrinkAuxiliaryData20.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
gc/g1/TestShrinkDefragmentedHeap.java: Verify that heap shrinks after GC in the presence of fragmentation due to humongous objects 1.
gc/g1/TestShrinkToOneRegion.java: Shrinking the heap down to one region used to hit an assert
gc/g1/TestSkipRebuildRemsetPhase.java: Skip Rebuild Remset Phase if the Remark pause does not identify any rebuild candidates.
gc/g1/TestVerifyGCType.java: Test the VerifyGCType flag to ensure basic functionality.
gc/g1/humongousObjects/TestHumongousClassLoader.java: Checks that unreachable classes and unreachable humongous class loader are unloaded after GC
gc/g1/humongousObjects/TestHumongousMovement.java: Checks that Humongous objects are not moved during GC
gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java: Checks that huge class' instances (ie with huge amount of fields) are allocated successfully
gc/g1/humongousObjects/TestHumongousThreshold.java: Checks that objects larger than half a region are allocated as humongous
gc/g1/humongousObjects/TestNoAllocationsInHRegions.java: Checks that no additional allocations are made in humongous regions
gc/g1/humongousObjects/TestObjectCollected.java: checks that after different type of GCs weak/soft references to humongous object behave correspondingly to actual object behavior
gc/g1/ihop/TestIHOPStatic.java: Test checks concurrent cycle initiation which depends on IHOP value.
gc/g1/mixedgc/TestLogging.java: Check that a mixed GC is reflected in the gc logs
gc/g1/mixedgc/TestOldGenCollectionUsage.java: G1 Old Gen's CollectionUsage.used is zero after mixed GC which is incorrect
gc/g1/numa/TestG1NUMATouchRegions.java: Ensure the bottom of the given heap regions are properly touched with requested NUMA id.
gc/g1/plab/TestPLABEvacuationFailure.java: Checks PLAB statistics on evacuation failure
gc/g1/plab/TestPLABPromotion.java: Test PLAB promotion
gc/g1/plab/TestPLABResize.java: Test for PLAB resizing
gc/logging/TestDeprecatedPrintFlags.java: Verify PrintGC, PrintGCDetails and -Xloggc
gc/logging/TestGCId.java: Ensure that the GCId is logged
gc/logging/TestMetaSpaceLog.java: Ensure that the Metaspace is updated in the log
gc/logging/TestPrintReferences.java: Validate the reference processing logging
gc/metaspace/G1AddMetaspaceDependency.java: Checks that we don't get locking problems when adding metaspace dependencies with the G1 update buffer monitor
gc/metaspace/TestMetaspaceInitialization.java: Tests to initialize metaspace with a very low MetaspaceSize
gc/metaspace/TestMetaspaceMemoryPool.java: Tests that a MemoryPoolMXBeans is created for metaspace and that a MemoryManagerMXBean is created.
gc/metaspace/TestMetaspacePerfCounters.java#Epsilon-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#G1-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Parallel-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Serial-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Shenandoah-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspaceSizeFlags.java: Test that metaspace size flags can be set correctly
gc/metaspace/TestPerfCountersAndMemoryPools.java#id0: Tests that a MemoryPoolMXBeans and PerfCounters for metaspace report the same data.
gc/metaspace/TestSizeTransitions.java#id0: Tests that the metaspace size transition logging is done correctly.
gc/metaspace/TestSizeTransitions.java#id1: Tests that the metaspace size transition logging is done correctly.
gc/metaspace/TestSizeTransitions.java#id2: Tests that the metaspace size transition logging is done correctly.
gc/parallel/TestDynShrinkHeap.java: Verify that the heap shrinks after full GC according to the current values of the Min/MaxHeapFreeRatio flags
gc/parallel/TestPrintGCDetailsVerbose.java: Tests that jvm with maximally verbose GC logging does not crash when ParOldGC has no memory
gc/serial/HeapChangeLogging.java: Allocate to get a promotion failure and verify that that heap change logging is present.
gc/shenandoah/TestAllocHumongousFragment.java#adaptive: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#aggressive: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#compact: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#iu: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#iu-aggressive: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#passive: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocHumongousFragment.java#static: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/shenandoah/TestAllocIntArrays.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#iu: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#no-tlab: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#iu: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#no-tlab: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#aggressive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#iu: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#iu-aggressive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestArrayCopyCheckCast.java:
gc/shenandoah/TestArrayCopyStress.java:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#adaptive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#aggressive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#compact:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#iu:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#iu-aggressive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#passive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#static:
gc/shenandoah/TestElasticTLAB.java: Test that Shenandoah is able to work with elastic TLABs
gc/shenandoah/TestEvilSyncBug.java: Tests for crash/assert when attaching init thread during shutdown
gc/shenandoah/TestGCThreadGroups.java#default: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestGCThreadGroups.java#iu: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestGCThreadGroups.java#passive: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestHeapUncommit.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestHeapUncommit.java#default-lp:
gc/shenandoah/TestHeapUncommit.java#iu: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestHeapUncommit.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestHumongousThreshold.java#16b:
gc/shenandoah/TestHumongousThreshold.java#default:
gc/shenandoah/TestLargeObjectAlignment.java: Shenandoah crashes with -XX:ObjectAlignmentInBytes=16
gc/shenandoah/TestLotsOfCycles.java#adaptive:
gc/shenandoah/TestLotsOfCycles.java#aggressive:
gc/shenandoah/TestLotsOfCycles.java#compact:
gc/shenandoah/TestLotsOfCycles.java#iu:
gc/shenandoah/TestLotsOfCycles.java#iu-aggressive:
gc/shenandoah/TestLotsOfCycles.java#passive:
gc/shenandoah/TestLotsOfCycles.java#static:
gc/shenandoah/TestObjItrWithHeapDump.java: Test heap dump triggered heap object iteration
gc/shenandoah/TestParallelRefprocSanity.java: Test that reference processing works with both parallel and non-parallel variants.
gc/shenandoah/TestPeriodicGC.java: Test that periodic GC is working
gc/shenandoah/TestReferenceRefersToShenandoah.java#iu:
gc/shenandoah/TestReferenceRefersToShenandoah.java#iu-100:
gc/shenandoah/TestReferenceRefersToShenandoah.java#satb:
gc/shenandoah/TestReferenceRefersToShenandoah.java#satb-100:
gc/shenandoah/TestReferenceShortcutCycle.java#iu-100:
gc/shenandoah/TestReferenceShortcutCycle.java#satb-100:
gc/shenandoah/TestRefprocSanity.java#default: Test that null references/referents work fine
gc/shenandoah/TestRefprocSanity.java#iu: Test that null references/referents work fine
gc/shenandoah/TestRegionSampling.java#adaptive:
gc/shenandoah/TestRegionSampling.java#aggressive:
gc/shenandoah/TestRegionSampling.java#compact:
gc/shenandoah/TestRegionSampling.java#iu:
gc/shenandoah/TestRegionSampling.java#iu-aggressive:
gc/shenandoah/TestRegionSampling.java#passive:
gc/shenandoah/TestRegionSampling.java#static:
gc/shenandoah/TestResizeTLAB.java#adaptive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#aggressive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#compact: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#iu: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#iu-aggressive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#passive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#static: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestRetainObjects.java#adaptive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#aggressive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#compact: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#iu: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#iu-aggressive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#no-tlab: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#passive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#static: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#adaptive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#compact: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#iu: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#no-tlab: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#passive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#static: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSmallHeap.java:
gc/shenandoah/TestStringDedup.java#default: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringDedup.java#iu: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringDedup.java#passive: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringInternCleanup.java#default: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestStringInternCleanup.java#iu: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestStringInternCleanup.java#passive: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestVerifyJCStress.java#default: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyJCStress.java#iu: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyJCStress.java#iu-c1: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyJCStress.java#passive: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyLevels.java:
gc/shenandoah/TestWithLogLevel.java: Test Shenandoah with different log levels
gc/shenandoah/TestWrongArrayMember.java:
gc/shenandoah/compiler/BarrierInInfiniteLoop.java: Shenandoah: assert(mem == __null) failed: only one safepoint
gc/shenandoah/compiler/CallMultipleCatchProjs.java: barrier expansion breaks if barrier is right after call to rethrow stub
gc/shenandoah/compiler/FoldIfAfterExpansion.java: CTW: C2 (Shenandoah) compilation fails with "Range check dependent CastII node was not removed"
gc/shenandoah/compiler/LRBRightAfterMemBar.java: Shenandoah: assert(_base == Tuple) failure during C2 compilation
gc/shenandoah/compiler/TestBadRawMemoryAfterCall.java: Shenandoah: "graph should be schedulable" assert failure
gc/shenandoah/compiler/TestBarrierAboveProj.java: assert(_base == Tuple) failed: Not a Tuple after JDK-8280799
gc/shenandoah/compiler/TestBarrierExpandCallProjection.java: Shenandoah: crash in CallNode::extract_projections
gc/shenandoah/compiler/TestBarrierExpansionDeadMemPhi.java: C2 failures after JDK-8255000
gc/shenandoah/compiler/TestC1ArrayCopyNPE.java: test C1 arraycopy intrinsic
gc/shenandoah/compiler/TestC1VectorizedMismatch.java: test C1 vectorized mismatch intrinsic
gc/shenandoah/compiler/TestClone.java#aggressive: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#default: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#default-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops-aggressive: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestLinkToNativeRBP.java: guarantee(loc != NULL) failed: missing saved register with native invoke
gc/shenandoah/compiler/TestLoadBypassesNullCheck.java: C2/Shenandoah: SEGV in compiled code when running jcstress
gc/shenandoah/compiler/TestLoadPinnedAfterCall.java: CTW: C2 (Shenandoah) compilation fails with SEGV due to unhandled catchproj == NUL
gc/shenandoah/compiler/TestMaybeNullUnsafeAccess.java: cast before unsafe access moved in dominating null check null path causes crash
gc/shenandoah/compiler/TestNullCheck.java: implicit null check on brooks pointer must not cause crash
gc/shenandoah/compiler/TestReferenceCAS.java#default: Shenandoah reference CAS test
gc/shenandoah/compiler/TestReferenceCAS.java#no-coops: Shenandoah reference CAS test
gc/shenandoah/compiler/TestShenandoahCmpPAfterCall.java: Shenandoah: C2 assertion fails in Matcher::collect_null_checks
gc/shenandoah/compiler/TestShenandoahLRBInOuterStripMinedLoop.java: CTW: C2 (Shenandoah) compilation fails with SEGV in SBC2Support::pin_and_expand
gc/shenandoah/compiler/TestSinkingNodeDropsNotNullCast.java: Sinking node may cause required cast to be dropped
gc/shenandoah/compiler/TestUnexpectedIUBarrierEA.java: Shenandoah: Some tests failed with "EA: missing allocation reference path"
gc/shenandoah/compiler/TestUnsafeLoadStoreMergedHeapStableTests.java: fusion of heap stable test causes GetAndSet node to be removed
gc/shenandoah/compiler/TestUnsafeOffheapSwap.java: Miscompilation in Unsafe off-heap swap routines
gc/shenandoah/jni/TestJNICritical.java: test JNI critical arrays support in Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#aggressive: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#aggressive-verify: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestPinnedGarbage.java#aggressive: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestPinnedGarbage.java#passive: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestPinnedGarbage.java#verify: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestStringCriticalWithDedup.java#id0: Test string deduplication should not cause string critical to crash VM
gc/shenandoah/jni/TestStringCriticalWithDedup.java#id1: Test string deduplication should not cause string critical to crash VM
gc/shenandoah/jvmti/TestHeapDump.java#aggressive: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#aggressive-strdedup: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#no-coops-aggressive: Tests JVMTI heap dumps
gc/shenandoah/mxbeans/TestChurnNotifications.java#adaptive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#aggressive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#compact: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#iu: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#passive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#static: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestMemoryMXBeans.java: Test JMX memory beans
gc/shenandoah/mxbeans/TestMemoryPools.java: Test JMX memory pools
gc/shenandoah/mxbeans/TestPauseNotifications.java#adaptive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#aggressive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#compact: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#iu: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#passive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#static: Check that MX notifications are reported for all cycles
gc/shenandoah/oom/TestAllocLargeObj.java: Test allocation of small object to result OOM, but not to crash JVM
gc/shenandoah/oom/TestAllocLargerThanHeap.java: Test that allocation of the object larger than heap fails predictably
gc/shenandoah/oom/TestAllocSmallObj.java: Test allocation of small object to result OOM, but not to crash JVM
gc/shenandoah/oom/TestClassLoaderLeak.java: Test OOME in due to classloader leak
gc/shenandoah/oom/TestThreadFailure.java: Test OOME in separate thread is recoverable
gc/shenandoah/options/TestAlwaysPreTouch.java: Check that Shenandoah's AlwaysPreTouch does not fire asserts
gc/shenandoah/options/TestArgumentRanges.java: Test that Shenandoah arguments are checked for ranges where applicable
gc/shenandoah/options/TestClassUnloadingArguments.java: Test that loop mining arguments are sane
gc/shenandoah/options/TestEnabled.java#default:
gc/shenandoah/options/TestExplicitGC.java: Test that Shenandoah reacts to explicit GC flags appropriately
gc/shenandoah/options/TestExplicitGCNoConcurrent.java: Test that Shenandoah reacts to explicit GC flags appropriately
gc/shenandoah/options/TestHeuristicsUnlock.java: Test that Shenandoah heuristics are unlocked properly
gc/shenandoah/options/TestHumongousMoves.java: Check Shenandoah reacts on setting humongous moves correctly
gc/shenandoah/options/TestHumongousThresholdArgs.java: Test that Shenandoah humongous threshold args are checked
gc/shenandoah/options/TestLargePages.java#default:
gc/shenandoah/options/TestLargePages.java#lp:
gc/shenandoah/options/TestLargePages.java#thp:
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#default: when heap is too small for regions to align to large page size, should fallback to regular page size
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#lp:
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#thp:
gc/shenandoah/options/TestLoopMiningArguments.java: Test that loop mining arguments are sane
gc/shenandoah/options/TestModeUnlock.java: Test that Shenandoah modes are unlocked properly
gc/shenandoah/options/TestObjectAlignment.java#16b:
gc/shenandoah/options/TestObjectAlignment.java#default:
gc/shenandoah/options/TestPacing.java:
gc/shenandoah/options/TestParallelRegionStride.java:
gc/shenandoah/options/TestRegionSizeArgs.java: Test that Shenandoah region size args are checked
gc/shenandoah/options/TestSelectiveBarrierFlags.java#id0: Test selective barrier enabling works, by aggressively compiling HelloWorld with combinations of barrier flags
gc/shenandoah/options/TestSingleThreaded.java: test single worker threaded Shenandoah
gc/shenandoah/options/TestSoftMaxHeapSize.java: Test that Shenandoah checks SoftMaxHeapSize
gc/shenandoah/options/TestThreadCounts.java: Test that Shenandoah GC thread counts are handled well
gc/shenandoah/options/TestThreadCountsOverride.java: Test that Shenandoah GC thread counts are overridable
gc/shenandoah/options/TestWrongBarrierDisable.java: Test that disabling wrong barriers fails early
gc/shenandoah/options/TestWrongBarrierEnable.java: Test that disabling wrong barriers fails early
gc/startup_warnings/TestG1.java: Test that the G1 collector does not print a warning message
gc/startup_warnings/TestParallelGC.java: Test that ParallelGC does not print a warning message
gc/startup_warnings/TestSerialGC.java: Test that SerialGC does not print a warning message
gc/startup_warnings/TestShenandoah.java: Test that the Shenandoah collector does not print a warning message
gc/stress/CriticalNativeStress.java#id0: test argument pinning by nmethod wrapper of critical native method
gc/stress/CriticalNativeStress.java#id2: test argument unpacking nmethod wrapper of critical native method
gc/stress/gcold/TestGCOldWithG1.java: Stress the G1 GC by trying to make old objects more likely to be garbage than young objects.
gc/stress/gcold/TestGCOldWithParallel.java: Stress the Parallel GC by trying to make old objects more likely to be garbage than young objects.
gc/stress/gcold/TestGCOldWithSerial.java: Stress the Serial GC by trying to make old objects more likely to be garbage than young objects.
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#id0: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#id1: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationFullGC.java#id0: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationFullGC.java#id1: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationInterned.java#id0: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationInterned.java#id1: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationPrintOptions.java#id0: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationPrintOptions.java#id1: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationTableResize.java#id0: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationTableResize.java#id1: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationYoungGC.java#id0: Test string deduplication during young GC
gc/stringdedup/TestStringDeduplicationYoungGC.java#id1: Test string deduplication during young GC
gc/whitebox/TestConcMarkCycleWB.java: Verifies that ConcurrentMarking-related WB works properly
gc/whitebox/TestWBGC.java: Test to verify that WB methods isObjectInOldGen and youngGC work correctly.
gc/z/TestAllocateHeapAt.java: Test ZGC with -XX:AllocateHeapAt
gc/z/TestAlwaysPreTouch.java: Test ZGC parallel pre-touch
gc/z/TestGarbageCollectorMXBean.java: Test ZGC garbage collector MXBean
gc/z/TestHighUsage.java: Test ZGC "High Usage" rule
gc/z/TestMemoryMXBean.java: Test ZGC heap memory MXBean
gc/z/TestMemoryManagerMXBean.java: Test ZGC memory manager MXBean
gc/z/TestNoUncommit.java: Test ZGC uncommit unused memory disabled
gc/z/TestPageCacheFlush.java: Test ZGC page cache flushing
gc/z/TestRelocateInPlace.java: Test ZGC in-place relocateion
gc/z/TestSmallHeap.java: Test ZGC with small heaps
gc/z/TestUncommit.java: Test ZGC uncommit unused memory
gtest/GTestWrapper.java: a jtreg wrapper for gtest tests
gtest/LargePageGtests.java#use-large-pages: Run metaspace-related gtests for reclaim policy none (with verifications)
gtest/LargePageGtests.java#use-large-pages-1G: Run metaspace-related gtests for reclaim policy none (with verifications)
gtest/LargePageGtests.java#use-large-pages-sysV: Run metaspace-related gtests for reclaim policy none (with verifications)
gtest/MetaspaceGtests.java#balanced-no-ccs: Run metaspace-related gtests with compressed class pointers off
gtest/MetaspaceGtests.java#reclaim-aggressive-ndebug: Run metaspace-related gtests for reclaim policy aggressive
gtest/MetaspaceGtests.java#reclaim-none-ndebug: Run metaspace-related gtests for reclaim policy none
gtest/NMTGtests.java#nmt-detail: Run NMT-related gtests with detailed statistics
gtest/NMTGtests.java#nmt-off: Run NMT-related gtests with NMT switched off
gtest/NMTGtests.java#nmt-summary: Run NMT-related gtests with summary statistics
runtime/6294277/SourceDebugExtension.java: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
runtime/6626217/bug_21227.java: Loader-constraint table allows arrays instead of only the base-classes
runtime/6981737/Test6981737.java: check for correct vm properties
runtime/7100935/TestConjointAtomicArraycopy.java: verify that oops are copied element-wise atomic
runtime/7100935/TestShortArraycopy.java: verify that shorts are copied element-wise atomic.
runtime/7158988/FieldMonitor.java: verify jvm does not crash while debugging
runtime/7160757/Test7160757.java: Tests that superclass initialization is not skipped
runtime/7162488/TestUnrecognizedVmOption.java: VM should print unrecognized -XX option
runtime/7167069/PrintAsFlag.java: verify that Flag::print_as_flag() works correctly.
runtime/8007320/ConstMethodTest.java: Test all optional fields in ConstMethod
runtime/8007475/StackMapFrameTest.java: Test memory stomp in stack map test
runtime/8010389/VMThreadDlopen.java:
runtime/8024804/RegisterNatives.java: interface method resolution should skip finding j.l.Object's registerNatives() and succeed in selecting class B's registerNatives()
runtime/AccModule/ACCModule52.java: Test that the JVM ignores ACC_MODULE if it is set for a version 52 class file.
runtime/AccModule/ConstModule.java: Test scenarios for constant pool CONSTANT_Module and CONSTANT_Package types, for class file versions 53 and 52, when ACC_MODULE is set and not set in the access_flags.
runtime/Annotations/TestAnnotatedStringEncoding.java: Tests the correct encoding of latin1/UTF16 Strings used in annotations.
runtime/BadObjectClass/BootstrapRedefine.java: Give error if java.lang.Object has been incompatibly overridden on the bootpath
runtime/BadObjectClass/TestUnloadClassError.java: Make sure the VM doesn't crash and throws a SecurityException if defineClass() is called on a byte buffer that parses into a invalid java.lang.Object class.
runtime/BoolReturn/JNIBooleanTest.java: [s390x] Interpreter doesn't call result handler after native calls
runtime/BoolReturn/NativeSmallIntCallsTest.java: Test native functions return booleans as 0/1 but differently than java functions
runtime/BootClassAppendProp/BootClassPathAppend.java: Uninitialized system property jdk.boot.class.path.append causes SIGSEGV
runtime/BootClassAppendProp/BootClassPathAppendProp.java:
runtime/BootClassAppendProp/SunBootClassPath.java: Make sure property sun.boot.class.path is null starting with JDK-9.
runtime/BootstrapMethod/BSMCalledTwice.java#id0:
runtime/BootstrapMethod/TestLambdaExceptionInInitializer.java:
runtime/CDSCompressedKPtrs/CDSCompressedKPtrs.java: Testing UseCompressedClassPointers with CDS
runtime/CDSCompressedKPtrs/XShareAuto.java: -Xshare:auto is the default when -Xshare is not specified
runtime/CheckUnhandledOops/TestOutOfMemory.java:
runtime/ClassFile/FormatCheckingTest.java: Ensure class name loaded by app class loader is format checked by default
runtime/ClassFile/JsrRewriting.java: JSR (jump local subroutine) rewriting can overflow memory address size variables
runtime/ClassFile/OomWhileParsingRepeatedJsr.java: Testing class file parser; specifically parsing a file with repeated JSR (jump local subroutine) bytecode command.
runtime/ClassFile/PreviewVersion.java: Check that preview minor version and --enable-preview are handled correctly.
runtime/ClassFile/TestCheckedExceptions.java: Check that having a method with an interface type in its throws clause does not cause the JVM to assert nor throw an exception.
runtime/ClassFile/UnsupportedClassFileVersion.java:
runtime/ClassInitErrors/InitExceptionUnloadTest.java: Test that the NCDFE saves the stack trace for the original exception during class initialization with ExceptionInInitializationError, and doesn't prevent the classes in the stacktrace to be unloaded.
runtime/ClassResolutionFail/TestClassResolutionFail.java: This tests that failed class resolution doesn't report different class name in detail message for the first and subsequent times
runtime/ClassUnload/ConstantPoolDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through constant pool reference
runtime/ClassUnload/DictionaryDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through reflection
runtime/ClassUnload/KeepAliveClass.java: This test case uses a java.lang.Class instance to keep a class alive.
runtime/ClassUnload/KeepAliveClassLoader.java: This test case uses a java.lang.ClassLoader instance to keep a class alive.
runtime/ClassUnload/KeepAliveObject.java: This test case uses a class instance to keep the class alive.
runtime/ClassUnload/KeepAliveSoftReference.java: This test case uses a java.lang.ref.SoftReference referencing a class instance to keep a class alive.
runtime/ClassUnload/SuperDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through subclassing
runtime/ClassUnload/UnloadInterfaceTest.java:
runtime/ClassUnload/UnloadTest.java:
runtime/CommandLine/BooleanFlagWithInvalidValue.java: Setting an invalid value for a bool argument should result in a useful error message
runtime/CommandLine/CompilerConfigFileWarning.java: Warn if unused .hotspot_compiler file is present
runtime/CommandLine/ConfigFileParsing.java: Improve config file parsing
runtime/CommandLine/ConfigFileWarning.java: Warn if unused .hotspot_rc file is present
runtime/CommandLine/DoubleFlagWithIntegerValue.java: Command-line flags of type double should accept integer values
runtime/CommandLine/FlagWithInvalidValue.java: Setting a flag to an invalid value should print a useful error message
runtime/CommandLine/IgnoreUnrecognizedVMOptions.java: -XX:+IgnoreUnrecognizedVMOptions should work according to the spec from JDK-8129855
runtime/CommandLine/NonBooleanFlagWithInvalidBooleanPrefix.java: Using a bool (+/-) prefix on non-bool flag should result in a useful error message
runtime/CommandLine/OptionsValidation/TestJcmdOutput.java: Verify jcmd error message for out-of-range value and for value which is not allowed by constraint.
runtime/CommandLine/OptionsValidation/TestOptionsWithRangesDynamic.java: Test writeable VM Options with ranges.
runtime/CommandLine/PrintGCApplicationConcurrentTime.java:
runtime/CommandLine/PrintTouchedMethods.java:
runtime/CommandLine/PrintTouchedMethodsJcmd.java: Test jcmd PrintTouchedMethods VM.print_touched_methods
runtime/CommandLine/TestHexArguments.java: Make sure there is no error using hexadecimal format in vm options
runtime/CommandLine/TestLongUnrecognizedVMOption.java: Verify that JVM correctly processes very long unrecognized VM option
runtime/CommandLine/TestNullTerminatedFlags.java: Test that the VM don't allow random junk characters at the end of valid command line flags.
runtime/CommandLine/TestVMOptions.java: Test various command line options
runtime/CommandLine/TraceExceptionsTest.java: -Xlog:exceptions=info output should have the exception message - useful for ClassNotFoundExceptions especially
runtime/CommandLine/UnrecognizedProperty.java: VM should not crash with property "-D-D"
runtime/CommandLine/UnrecognizedVMOption.java: Using an unrecognized VM option should print the name of the option
runtime/CommandLine/VMAliasOptions.java: Test that various alias options correctly set the target options.
runtime/CommandLine/VMDeprecatedOptions.java: Test that various options are deprecated.
runtime/CommandLine/VMOptionWarning.java: Warn if diagnostic or experimental vm option is used and -XX:+UnlockDiagnosticVMOptions or -XX:+UnlockExperimentalVMOptions, respectively, isn't specified.
runtime/CommandLine/VMOptionsFile/TestVMOptionsFile.java: Test "-XX:VMOptionsFile" VM option
runtime/CompactStrings/TestMethodNames.java: Test method names containing Latin-1 supplement characters.
runtime/CompressedOops/CompressedClassSpaceSize.java: Tests for the -XX:CompressedClassSpaceSize command line option
runtime/CompressedOops/CompressedKlassPointerAndOops.java: NPG: UseCompressedClassPointers asserts with ObjectAlignmentInBytes=32
runtime/CompressedOops/ObjectAlignment.java: Tests for the -XX:ObjectAlignmentInBytes command line option
runtime/CompressedOops/UseCompressedOops.java: Tests for different combination of UseCompressedOops options
runtime/ConstantPool/BadMethodHandles.java: Adding constantTag to keep method call consistent with it.
runtime/ConstantPool/IntfMethod.java: Adding constantTag to keep method call consistent with it.
runtime/ConstantPool/TestMethodHandleConstant.java: Test that MethodHandle constants are checked
runtime/CreateMirror/ArraysNewInstanceBug.java: race in setting array_klass field for component mirror with mirror update for klass
runtime/DefineClass/NullClassBytesTest.java: Verifies DefineClass with null or truncate bytes gets appropriate exception
runtime/Dictionary/CleanProtectionDomain.java: Verifies the creation and cleaup of entries in the Protection Domain Table
runtime/Dictionary/ProtectionDomainCacheTest.java: Call Class.forName() on the system classloader from a class loaded from a custom classloader, using the current class's protection domain.
runtime/ElfDecoder/TestElfDirectRead.java#id0: Test reading ELF info direct from underlaying file
runtime/EnclosingMethodAttr/EnclMethodAttr.java: Check attribute_length of EnclosingMethod attribute
runtime/ErrorHandling/CreateCoredumpOnCrash.java:
runtime/ErrorHandling/MachCodeFramesInErrorFile.java: Test that abstract machine code is dumped for the top frames in a hs-err log
runtime/ErrorHandling/ProblematicFrameTest.java: Test that error is not occurred during printing problematic frame
runtime/ErrorHandling/TestCrashOnOutOfMemoryError.java: Test using -XX:+CrashOnOutOfMemoryError
runtime/ErrorHandling/TestExitOnOutOfMemoryError.java: Test using -XX:ExitOnOutOfMemoryError
runtime/ErrorHandling/TestGZippedHeapDumpOnOutOfMemoryError.java#id0: Test verifies that -XX:HeapDumpGzipLevel=0 works
runtime/ErrorHandling/TestGZippedHeapDumpOnOutOfMemoryError.java#id1: Test verifies that -XX:HeapDumpGzipLevel=1 works
runtime/ErrorHandling/TestHeapDumpOnOutOfMemoryError.java#id0: Test verifies that -XX:HeapDumpOnOutOfMemoryError dumps heap when OutOfMemory is thrown in heap
runtime/ErrorHandling/TestHeapDumpOnOutOfMemoryError.java#id1: Test verifies that -XX:HeapDumpOnOutOfMemoryError dumps heap when OutOfMemory is thrown in metaspace.
runtime/ErrorHandling/TestHeapDumpPath.java: Test verifies that -XX:HeapDumpPath= supports directory as a parameter.
runtime/ErrorHandling/TestOnOutOfMemoryError.java: Test using single and multiple -XX:OnOutOfMemoryError=<cmd>
runtime/FieldLayout/FieldDensityTest.java#id0: Verify behaviour of field layout algorithm
runtime/FieldLayout/FieldDensityTest.java#id1:
runtime/FieldLayout/OldLayoutCheck.java#id0: -XX:-UseEmptySlotsInSupers sometime fails to reproduce the layout of the old code
runtime/Final/PutfieldError.java: Throw ICCE rather than crashing for nonstatic final field in static initializer
runtime/Final/TestPutMain.java: The VM does not always perform checks added by 8157181 when updating final instance fields
runtime/GenerateOopMap/TestGenerateOopMapCrash.java: Test that GenerateOopMap does not crash if last bytecode is a conditional branch
runtime/HiddenClasses/CastToParentTest.java: Test that a hidden class can be cast to its parent.
runtime/HiddenClasses/DefineHiddenClass.java:
runtime/HiddenClasses/FieldInSuper.java: Test that verifer assignability checks involving the 'this' pointer work ok for hidden classes.
runtime/HiddenClasses/GCHiddenClass.java: Test that hidden classes get garbage collected.
runtime/HiddenClasses/HiddenClassStack.java: Test that stack tracing isn't broken if an exception is thrown in a hidden class.
runtime/HiddenClasses/HiddenDefMeths.java: Tests a hidden class that implements interfaces with default methods.
runtime/HiddenClasses/HiddenGetModule.java: Test that a hidden class has the same module as its lookup class.
runtime/HiddenClasses/InstantiateHiddenClass.java: Test issues with instantiating hidden classes.
runtime/HiddenClasses/NestedHidden.java: Creates a hidden class inside of a hidden class.
runtime/HiddenClasses/TestHiddenClassUnloading.java: Test unloading of hidden classes.
runtime/InnerClassesAttr/InnerClassesTest.jasm:
runtime/InternalApi/ThreadCpuTimesDeadlock.java#id0: Possible JVM deadlock in ThreadTimesClosure when using HotspotInternal non-public API.
runtime/JVMDoPrivileged/DoPrivRunAbstract.jasm: Test that AccessController.doPrivileged throws java.lang.AbstractMethodError for an abstract run() method.
runtime/JVMDoPrivileged/DoPrivileged.java: Test that AccessController.doPrivileged() searches default methods when looking for the run() method.
runtime/LoadClass/LoadClassNegative.java: make sure there is no fatal error if a class is loaded from an invalid jar file which is in the bootclasspath
runtime/LoadClass/ShowClassLoader.java: Make sure array class has the right class loader
runtime/LoadLibrary/TestSunBootLibraryPath.java: Confirm using too-long paths in sun.boot.library.path causes failure and useful error message.
runtime/LoaderConstraints/differentLE/Test.java: Test exception messages of LinkageError.
runtime/LoaderConstraints/duplicateLE/Test.java: Test exception messages of LinkageError.
runtime/LoaderConstraints/duplicateParentLE/Test.java: Test exception messages of LinkageError with a parent class loader that is not known to the VM.
runtime/LoaderConstraints/itableICCE/Test.java:
runtime/LoaderConstraints/itableLdrConstraint/Test.java:
runtime/LoaderConstraints/ldrCnstrFldMsg/LdrCnstrFldMsgTest.java:
runtime/LoaderConstraints/vtableAME/Test.java:
runtime/LoaderConstraints/vtableLdrConstraint/Test.java:
runtime/LocalLong/LocalLongTest.java:
runtime/LocalVariableTable/TestLVT.java: Test ClassFileParser::copy_localvariable_table cases
runtime/Locals/TestLargeLocalVarsStackRegion.java:
runtime/MemberName/MemberNameLeak.java: MemberNameTable should reuse entries
runtime/Metaspace/DefineClass.java: Failures during class definition can lead to memory leaks in metaspace
runtime/Metaspace/FragmentMetaspace.java:
runtime/Metaspace/FragmentMetaspaceSimple.java:
runtime/Metaspace/MaxMetaspaceSizeEnvVarTest.java: test that setting via the env-var and options file shows up as expected
runtime/Metaspace/MaxMetaspaceSizeTest.java:
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-ccs: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-ccs-aggressivereclaim: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-ccs-noreclaim: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-noccs: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-nospecified: Test the VM.metaspace command
runtime/Metaspace/elastic/TestMetaspaceAllocation.java#ndebug:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT1.java#ndebug-aggressive:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT1.java#ndebug-default:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT1.java#ndebug-none:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT2.java#ndebug-aggressive:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT2.java#ndebug-default:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT2.java#ndebug-none:
runtime/MirrorFrame/Test8003720.java: Method in interpreter stack frame can be deallocated
runtime/Monitor/DeflationIntervalsTest.java#allIntervalsZero:
runtime/Monitor/DeflationIntervalsTest.java#allThresholdsZero:
runtime/Monitor/DeflationIntervalsTest.java#defaults: Test the deflation intervals options
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdADI_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdADI_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdMUDT_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdMUDT_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_threshold_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_threshold_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#noGuaranteedGADT_threshold_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#noGuaranteedGADT_threshold_safepoint:
runtime/Monitor/MonitorUnlinkBatchTest.java#aggressive:
runtime/Monitor/MonitorUnlinkBatchTest.java#defaults: Test the MonitorUnlinkBatch options
runtime/Monitor/MonitorUnlinkBatchTest.java#illegal:
runtime/Monitor/MonitorUnlinkBatchTest.java#lazy:
runtime/Monitor/MonitorUnlinkBatchTest.java#legal:
runtime/Monitor/MonitorUsedDeflationThresholdTest.java: Test the MonitorUsedDeflationThreshold and NoAsyncDeflationProgressMax options.
runtime/Monitor/NonOwnerOps.java: Verify that monitor operations by a non-owner thread throw IllegalMonitorStateException.
runtime/Monitor/SyncOnValueBasedClassTest.java: Exercise DiagnoseSyncOnValueBasedClasses diagnostic flag
runtime/NMT/BaselineWithParameter.java: Regression test for invoking a jcmd with baseline=false, result was that the target VM crashed
runtime/NMT/CheckForProperDetailStackTrace.java: Running with NMT detail should produce expected stack traces.
runtime/NMT/CommandLineDetail.java: Running with NMT detail should not result in an error
runtime/NMT/CommandLineEmptyArgument.java: Empty argument to NMT should result in an informative error message
runtime/NMT/CommandLineInvalidArgument.java: Invalid argument to NMT should result in an informative error message
runtime/NMT/CommandLineSummary.java: Running with NMT summary should not result in an error
runtime/NMT/CommandLineTurnOffNMT.java: Turning off NMT should not result in an error
runtime/NMT/CommitOverlappingRegions.java: Test commits of overlapping regions of memory.
runtime/NMT/HugeArenaTracking.java:
runtime/NMT/JcmdBaselineDetail.java: Verify that jcmd correctly reports that baseline succeeds with NMT enabled with detailed tracking.
runtime/NMT/JcmdDetailDiff.java: run NMT baseline, allocate memory and verify output from detail.diff
runtime/NMT/JcmdScale.java: Test the NMT scale parameter
runtime/NMT/JcmdScaleDetail.java: Test the NMT scale parameter with detail tracking level
runtime/NMT/JcmdSummaryClass.java: Check class counters in summary report
runtime/NMT/JcmdSummaryDiff.java: run NMT baseline, allocate memory and verify output from summary.diff
runtime/NMT/JcmdWithNMTDisabled.java: Verify that jcmd correctly reports that NMT is not enabled
runtime/NMT/MallocRoundingReportTest.java: Test consistency of NMT by creating allocations of the Test type with various sizes and verifying visibility with jcmd
runtime/NMT/MallocSiteTypeChange.java:
runtime/NMT/MallocTestType.java: Test consistency of NMT by leaking a few select allocations of the Test type and then verify visibility with jcmd
runtime/NMT/MallocTrackingVerify.java: Test to verify correctness of malloc tracking
runtime/NMT/NMTForOtherLaunchersTest.java#jar:
runtime/NMT/NMTForOtherLaunchersTest.java#javac:
runtime/NMT/NMTInitializationTest.java#default_long-detail:
runtime/NMT/NMTInitializationTest.java#default_long-off:
runtime/NMT/NMTInitializationTest.java#normal-detail:
runtime/NMT/NMTInitializationTest.java#normal-off:
runtime/NMT/NMTWithCDS.java:
runtime/NMT/PrintNMTStatistics.java: Verify PrintNMTStatistics on normal JVM exit for detail and summary tracking level
runtime/NMT/PrintNMTStatisticsWithNMTDisabled.java: Trying to enable PrintNMTStatistics should result in a warning
runtime/NMT/ReleaseCommittedMemory.java: Release committed memory and make sure NMT handles it correctly
runtime/NMT/ReleaseNoCommit.java: Release uncommitted memory and make sure NMT handles it correctly
runtime/NMT/SafepointPollingPages.java: NMT should report safepoint polling page(s)
runtime/NMT/SummaryDiffThreadCount.java: run NMT baseline, create threads and verify output from summary.diff
runtime/NMT/SummarySanityCheck.java: Sanity check the output of NMT
runtime/NMT/ThreadedMallocTestType.java:
runtime/NMT/ThreadedVirtualAllocTestType.java:
runtime/NMT/UnsafeAllocMemory.java: Unsafe.allocateMemory should be tagged as Other
runtime/NMT/VirtualAllocAttemptReserveMemoryAt.java: Test that os::attempt_reserve_memory_at doesn't register the memory as committed
runtime/NMT/VirtualAllocCommitMerge.java: Test merging of committed virtual memory and that we track it correctly
runtime/NMT/VirtualAllocCommitUncommitRecommit.java: Test reserve/commit/uncommit/release of virtual memory and that we track it correctly
runtime/NMT/VirtualAllocTestType.java: Test Reserve/Commit/Uncommit/Release of virtual memory and that we track it correctly
runtime/Nestmates/classFileParsing/TestFinalMethodOverride.java: Test nestmate checks are no longer used when check_final_method_override is executed during parsing
runtime/Nestmates/classFileParsing/TestNestmateAttributes.java: Test incorrect use of Nestmate related attributes
runtime/Nestmates/legacy/TestPrivateLookup.java: Test that private Lookup works for both nestmate-enabled classes and legacy classes
runtime/Nestmates/membership/TestDynamicNestmateMembership.java: Test the rules for dynamic nest membership using the Lookup.defineHiddenClass API
runtime/Nestmates/membership/TestNestHostErrorWithClassUnload.java: Test the ability to safely unload a class that has an error with its designated nest host.
runtime/Nestmates/membership/TestNestHostErrorWithMultiThread.java: JVM crashes when two threads encounter the same resolution error
runtime/Nestmates/membership/TestNestmateMembership.java: Test the various rules for nest members and nest-hosts by triggering nestmate access checks on all possible paths
runtime/Nestmates/methodSelection/TestInterfaceMethodSelection.java: Test interface method selection process for private/public nestmate invocation
runtime/Nestmates/methodSelection/TestMethodSelection.java: Test method selection process for private/public nestmate invocation
runtime/Nestmates/privateConstructors/TestConstructorHierarchy.java: Test access to private constructors in the hierarchy that are outside the nest
runtime/Nestmates/privateConstructors/TestInvokeSpecial.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types that will generate invokespecial for the calls.
runtime/Nestmates/privateConstructors/TestJNI.java: Test JNI access to private constructors between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateConstructors/TestMethodHandles.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateConstructors/TestReflection.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateFields/TestJNI.java: Test JNI access to private fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateFields/TestMethodHandles.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateFields/TestPrivateField.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateFields/TestReflection.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateMethods/TestInvoke.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateMethods/TestInvokeErrors.java: Setup nestmate calls to private methods then use modified jcod classes to introduce errors.
runtime/Nestmates/privateMethods/TestInvokeHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestJNI.java: Test JNI access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateMethods/TestJNIHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestMethodHandles.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateMethods/TestMethodHandlesHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestReflection.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateMethods/TestReflectionHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateStaticFields/TestJNI.java: Test JNI access to private static fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticFields/TestMethodHandles.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateStaticFields/TestPrivateStaticField.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticFields/TestReflection.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateStaticMethods/TestInvokeStatic.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticMethods/TestJNI.java: Test JNI access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticMethods/TestMethodHandles.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateStaticMethods/TestReflection.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/protectionDomain/TestDifferentProtectionDomains.java: Test the code paths when a nest-host and nest-member class are in different protection domains and the compiler thread needs to perform a nestmate access check.
runtime/NonWriteableProperty.java: Ensure non-writeable system properties are not writeable
runtime/ParallelLoad/ParallelSuperTest.java: Call handle_parallel_super_load, loading parallel threads that throw CCE
runtime/ParallelLoad/SaveResolutionErrorTest.java: JVMS 5.4.3 If an attempt by the Java Virtual Machine to resolve a symbolic reference fails because an error is thrown that is an instance of LinkageError (or a subclass), then subsequent attempts to resolve the reference always fail with the same error that was thrown as a result of the initial resolution attempt.
runtime/PerfMemDestroy/PerfMemDestroy.java: Allow multiple calls to PerfMemory::destroy() without asserting.
runtime/PrintStringTableStats/PrintStringTableStatsTest.java:
runtime/ReservedStack/ReservedStackTest.java:
runtime/ReservedStack/ReservedStackTestCompiler.java: Run ReservedStackTest with dedicated compilers C1 and C2.
runtime/Safepoint/TestAbortOnVMOperationTimeout.java: Check abort on VM timeout is working
runtime/Safepoint/TestAbortVMOnSafepointTimeout.java: Check if VM can kill thread which doesn't reach safepoint.
runtime/SameObject/SameObject.java: -Xcheck:jni overly strict in JNI method IsSameObject Fixed in JDK1.3.1_10 Fixed in JDK1.4.1_07
runtime/SelectionResolution/AbstractMethodErrorTest.java: Test of method selection and resolution cases that generate AbstractMethodErrorTest
runtime/SelectionResolution/IllegalAccessErrorTest.java: Test of method selection and resolution cases that generate IllegalAccessErrorTest
runtime/SelectionResolution/InvokeInterfaceICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeInterfaceSuccessTest.java: Test of method selection and resolution cases that generate InvokeInterfaceSuccessTest
runtime/SelectionResolution/InvokeSpecialICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeSpecialSuccessTest.java: Test of method selection and resolution cases that generate InvokeSpecialSuccessTest
runtime/SelectionResolution/InvokeStaticICCE.java: Test of invokestatic method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeStaticSuccessTest.java: Test of method selection and resolution cases that generate InvokeStaticSuccessTest
runtime/SelectionResolution/InvokeVirtualICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeVirtualSuccessTest.java: Test of method selection and resolution cases that generate InvokeVirtualSuccessTest
runtime/SelectionResolution/NoSuchMethodErrorTest.java: Test of method selection and resolution cases that generate NoSuchMethodError
runtime/Shutdown/ShutdownTest.java: Make MutexLocker smarter about non-Java threads
runtime/StackGap/TestStackGap.java: Linux kernel stack guard should not cause segfaults on x86-32
runtime/StackGuardPages/TestStackGuardPages.java: Stack guard pages should be installed correctly and removed when thread is detached
runtime/StackGuardPages/TestStackGuardPagesNative.java: Stack guard pages should be installed correctly and removed when thread is detached for native threads
runtime/StackTrace/HiddenFrameTest.java: Test null source file and negative line number from hidden frame produces correct output.
runtime/StackTrace/LargeClassTest.java: JVM crashes on stack trace for large number of methods.
runtime/StackTrace/StackTraceClassCache.java: Check that stack trace contains proper strings even with class caching
runtime/StringIntrinsic/StringIndexOfChar.java: String.indexOf(char) for empty string must give -1
runtime/TLS/TestTLS.java: Test with extra TLS size.
runtime/Thread/CancellableThreadTest.java:
runtime/Thread/Fibonacci.java: Calculates Fibonacci numbers "recursively" via threads and compares the result with the classical calculation.
runtime/Thread/InterruptAtExit.java: Stress test java.lang.Thread.interrupt() at thread exit.
runtime/Thread/IsInterruptedAtExit.java: Stress test java.lang.Thread.isInterrupted() at thread exit.
runtime/Thread/SetNameAtExit.java: Stress test java.lang.Thread.setName() at thread exit.
runtime/Thread/SetPriorityAtExit.java: Stress test java.lang.Thread.setPriority() at thread exit.
runtime/Thread/StopAtExit.java: Stress test JVM/TI StopThread() at thread exit.
runtime/Thread/SuspendAtExit.java: Stress test SuspendThread at thread exit.
runtime/Thread/TestBreakSignalThreadDump.java#default: Check that Ctrl-\ or Ctrl-Break (on Windows) causes HotSpot VM to print a full thread dump.
runtime/Thread/TestBreakSignalThreadDump.java#with_jsig: Check that Ctrl-\ causes HotSpot VM to print a full thread dump when signal chaining is used.
runtime/Thread/TestThreadDumpClassInitMonitor.java: Check that the thread dump shows when a thread is blocked on a class initialization monitor
runtime/Thread/TestThreadDumpSMRInfo.java: Checks whether jstack reports a "Threads class SMR info" section.
runtime/Thread/TestThreadStackSizes.java: Test user threads with various stack sizes.
runtime/Thread/ThreadObjAccessAtExit.java: Use the WhiteBox API to ensure that we can safely access the threadObj oop of a JavaThread during termination, after it has removed itself from the main ThreadsList.
runtime/Thread/ThreadPriorities.java: Creates several threads with different java priorities and checks whether jstack reports correct priorities for them.
runtime/Thread/TooSmallStackSize.java: Setting small CompilerThreadStackSize, ThreadStackSize, and VMThreadStackSize values should result in an error message that shows the minimum stack size value for each thread type.
runtime/Throwable/StackTraceLogging.java: check stacktrace logging
runtime/Throwable/TestCatchThrowableOOM.java: Test catching Throwable doesn't trigger OOME
runtime/Throwable/TestMaxJavaStackTraceDepth.java: MaxJavaStackTraceDepth of zero is not handled correctly/consistently in the VM
runtime/Throwable/TestThrowable.java: Test exception depths, and code to get stack traces
runtime/Throwable/ThrowableIntrospectionSegfault.java: check backtrace field introspection
runtime/TransitiveOverrideCFV50/TransitiveOverrideCFV50.java:
runtime/Unsafe/AllocateInstance.java: Verifies the behaviour of Unsafe.allocateInstance
runtime/Unsafe/AllocateMemory.java: Verifies behaviour of Unsafe.allocateMemory
runtime/Unsafe/CopyMemory.java: Verifies behaviour of Unsafe.copyMemory
runtime/Unsafe/DefineClass.java: Verifies the behaviour of Unsafe.defineClass
runtime/Unsafe/FieldOffset.java: Verifies the behaviour of Unsafe.fieldOffset
runtime/Unsafe/GetField.java: Verifies behaviour of Unsafe.getField
runtime/Unsafe/GetPutAddress.java:
runtime/Unsafe/GetPutBoolean.java: Verify behaviour of Unsafe.get/putBoolean
runtime/Unsafe/GetPutByte.java: Verify behaviour of Unsafe.get/putByte
runtime/Unsafe/GetPutChar.java: Verify behaviour of Unsafe.get/putChar
runtime/Unsafe/GetPutDouble.java: Verify behaviour of Unsafe.get/putDouble
runtime/Unsafe/GetPutFloat.java: Verify behaviour of Unsafe.get/putFloat
runtime/Unsafe/GetPutInt.java:
runtime/Unsafe/GetPutLong.java: Verify behaviour of Unsafe.get/putLong
runtime/Unsafe/GetPutObject.java: Verify behaviour of Unsafe.get/putObject
runtime/Unsafe/GetPutShort.java: Verify behaviour of Unsafe.get/putShort
runtime/Unsafe/GetUncompressedObject.java:
runtime/Unsafe/InternalErrorTest.java: Check that SIGBUS errors caused by memory accesses in Unsafe_CopyMemory() and UnsafeCopySwapMemory() get converted to java.lang.InternalError exceptions.
runtime/Unsafe/PageSize.java: Make sure pageSize() returns a value that is a power of two
runtime/Unsafe/Reallocate.java:
runtime/Unsafe/SetMemory.java: Verifies that setMemory works correctly
runtime/Unsafe/ThrowException.java: Verify that throwException() can throw an exception
runtime/VerifierMessages/Test7116786.java: verify that VerifyError messages are as expected
runtime/VtableTests/VTableTest.java: Check that the vTable for class C gets set up without causing an assertion failure.
runtime/XCheckJniJsig/XCheckJSig.java: Need to suppress info message if -Xcheck:jni is used with libjsig.so
runtime/cds/ArchiveDoesNotExist.java: Test how VM handles "file does not exist" situation while attempting to use CDS archive.
runtime/cds/BootAppendTests.java: Testing -Xbootclasspath/a support for CDS
runtime/cds/CdsDifferentCompactStrings.java: CDS (class data sharing) requires the same -XX:[+-]CompactStrings setting between archive creation time and load time.
runtime/cds/CdsDifferentObjectAlignment.java: Testing CDS (class data sharing) using varying object alignment.
runtime/cds/CdsSameObjectAlignment.java: Testing CDS (class data sharing) using varying object alignment.
runtime/cds/CheckDefaultArchiveFile.java: JDK platforms/binaries do not support default CDS archive should not contain classes.jsa in the default location.
runtime/cds/CheckSharingWithDefaultArchive.java: Sharing should be enabled by default on supported platform/binaries.
runtime/cds/DumpSharedDictionary.java: Check that Shared Dictionary is printed out with jcmd
runtime/cds/DumpSymbolAndStringTable.java: Test jcmd VM.symboltable, VM.stringtable and VM.systemdictionary options
runtime/cds/MaxMetaspaceSize.java: Testing CDS dumping with the -XX:MaxMetaspaceSize=<size> option
runtime/cds/NonBootLoaderClasses.java: Test to ensure platform and app classes are archived when specified in classlist
runtime/cds/PrimitiveClassMirrors.java: Make sure the archived mirrors of the primitive classes have the proper module (java.base)
runtime/cds/PrintSharedArchiveAndExit.java: Testing -XX:+PrintSharedArchiveAndExit option
runtime/cds/ServiceLoaderTest.java: Make sure that the ServicesCatalogs for boot/platform/app loaders are properly archived.
runtime/cds/SharedArchiveFile.java: Testing new -XX:SharedArchiveFile=<file-name> option
runtime/cds/SharedBaseAddress.java#id0: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id1: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id2: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id3: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedStrings.java: Check to make sure that shared strings in the bootstrap CDS archive are actually shared
runtime/cds/SharedStringsDedup.java: Test -Xshare:auto with shared strings and -XX:+UseStringDeduplication
runtime/cds/SharedStringsRunAuto.java: Test -Xshare:auto with shared strings.
runtime/cds/SharedSymbolTableBucketSize.java: Test SharedSymbolTableBucketSize option
runtime/cds/SpaceUtilizationCheck.java: Check if the space utilization for shared spaces is adequate
runtime/cds/TestCDSVMCrash.java: Verify that an exception is thrown when the VM crashes during executeAndLog
runtime/cds/TestInterpreterMethodEntries.java#id0: Test interpreter method entries for intrinsics with CDS (class data sharing) and the intrinsic flag enabled during dump and disabled during use of the archive.
runtime/cds/TestInterpreterMethodEntries.java#id1: Test interpreter method entries for intrinsics with CDS (class data sharing) and the intrinsic flag disabled during dump and enabled during use of the archive.
runtime/cds/appcds/AppendClasspath.java: At run time, it is OK to append new elements to the classpath that was used at dump time.
runtime/cds/appcds/ArchiveRelocationTest.java: Testing relocation of CDS archive (during both dump time and run time)
runtime/cds/appcds/BadBSM.java: CDS dump should abort if a class file contains a bad BSM.
runtime/cds/appcds/BootClassPathMismatch.java: bootclasspath mismatch test.
runtime/cds/appcds/CDSandJFR.java: Make sure CDS and JFR work together.
runtime/cds/appcds/CaseSensitiveClassPath.java: Test case sensitive aspect of comparing class paths between dump time and archive use time
runtime/cds/appcds/ClassLoaderTest.java: Initiating and defining classloader test.
runtime/cds/appcds/ClassPathAttr.java: Class-Path: attribute in MANIFEST file
runtime/cds/appcds/CommandLineFlagCombo.java: Test command line flag combinations that could likely affect the behaviour of AppCDS
runtime/cds/appcds/CommandLineFlagComboNegative.java: Test command line flag combinations that differ between the dump and execute steps, in such way that they cause errors E.g.
runtime/cds/appcds/DirClasspathTest.java: Handling of directories in -cp is based on the classlist
runtime/cds/appcds/DumpClassList.java: DumpLoadedClassList should exclude generated classes, classes in bootclasspath/a and --patch-module.
runtime/cds/appcds/DumpClassListWithLF.java: Tests the format checking of LF_RESOLVE in classlist.
runtime/cds/appcds/ExtraSymbols.java: Adding extra symbols into CDS archive using -XX:SharedArchiveConfigFile
runtime/cds/appcds/FieldAnnotationsTest.java: Test for field annotations.
runtime/cds/appcds/FieldLayoutFlags.java: VM should work even if different field layout options are chosen between dump time and run time.
runtime/cds/appcds/FreeUnusedMetadata.java: Unused metadata created during dump time should be freed from the CDS archive.
runtime/cds/appcds/HelloExtTest.java: a simple test for loading a class using the platform class loader (which used to be called the "extension loader) in AppCDS
runtime/cds/appcds/HelloTest.java: Hello World test for AppCDS
runtime/cds/appcds/IgnoreEmptyClassPaths.java: Test the -XX:+IgnoreEmptyClassPaths flag
runtime/cds/appcds/JvmtiAddPath.java: JvmtiEnv::AddToBootstrapClassLoaderSearch and JvmtiEnv::AddToSystemClassLoaderSearch should disable AppCDS
runtime/cds/appcds/LambdaContainsOldInf.java: VM should not crash during CDS dump when a lambda proxy class contains an old version of interface.
runtime/cds/appcds/LambdaEagerInit.java: Run the LambdaEagerInitTest.java test in static CDS archive mode.
runtime/cds/appcds/LambdaProxyClasslist.java: Test some error handling on the "@lambda-proxy" entries in a classlist.
runtime/cds/appcds/LambdaVerificationFailedDuringDump.java: Dumping of lambda proxy classes should not crash VM in case the caller class has failed verification.
runtime/cds/appcds/LambdaWithOldClass.java: VM should not crash during CDS dump and run time when a lambda expression references an old version of class.
runtime/cds/appcds/LambdaWithUseImplMethodHandle.java: CDS cannot archive lambda proxy with useImplMethodHandle
runtime/cds/appcds/LongClassListPath.java: Test the handling of long path to the classlist file.
runtime/cds/appcds/LotsOfClasses.java: Try to archive lots of classes by searching for classes from the jrt:/ file system.
runtime/cds/appcds/MismatchedPathTriggerMemoryRelease.java: Mismatched path at runtime will cause reserved memory released
runtime/cds/appcds/MissingSuperTest.java: When super class is missing during dumping, no crash should happen.
runtime/cds/appcds/MoveJDKTest.java: Test that CDS still works when the JDK is moved to a new directory
runtime/cds/appcds/MultiProcessSharing.java: Run multiple processes with the same archive, ensure they share
runtime/cds/appcds/MultiReleaseJars.java: Test multi-release jar with AppCDS.
runtime/cds/appcds/NonExistClasspath.java: Handling of non-existent classpath elements during dump time and run time
runtime/cds/appcds/OldClassTest.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldInfExtendsInfDefMeth.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperClass.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperInf.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperInfIndirect.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/PackageSealing.java: AppCDS handling of package.
runtime/cds/appcds/ParallelLoad2.java: Load app classes from CDS archive in parallel threads.
runtime/cds/appcds/ParallelLoadTest.java: Load app classes from CDS archive in parallel threads
runtime/cds/appcds/PrintSharedArchiveAndExit.java: test the -XX:+PrintSharedArchiveAndExit flag
runtime/cds/appcds/ProhibitedPackage.java: AppCDS handling of prohibited package.
runtime/cds/appcds/ProtectionDomain.java: AppCDS handling of protection domain.
runtime/cds/appcds/RelativePath.java: Test relative paths specified in the -cp.
runtime/cds/appcds/RewriteBytecodesTest.java: Use Lookup.defineClass() to load a class with rewritten bytecode.
runtime/cds/appcds/SealingViolation.java: A jar file containing classes in the same package.
runtime/cds/appcds/SharedArchiveConsistency.java: SharedArchiveConsistency
runtime/cds/appcds/SharedBaseAddress.java: Test variety of values for SharedBaseAddress, in AppCDS mode, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/appcds/SharedPackages.java: AppCDS handling of package.
runtime/cds/appcds/SharedRegionAlignmentTest.java: Testing handling of CDS region alignment
runtime/cds/appcds/SignedJar.java: AppCDS handling of signed JAR.
runtime/cds/appcds/SpecifySysLoaderProp.java: If -Djava.system.class.loader=xxx is specified in command-line, disable archived non-system classes
runtime/cds/appcds/StaticArchiveWithLambda.java: Sanity test lambda proxy classes in static CDS archive.
runtime/cds/appcds/TestCombinedCompressedFlags.java: Testing different combination of CompressedOops and CompressedClassPointers
runtime/cds/appcds/TestWithProfiler.java: After creating an AppCDS archive, run the test with the JFR profiler enabled, and keep calling a method in the archive in a tight loop.
runtime/cds/appcds/TestZGCWithCDS.java:
runtime/cds/appcds/TraceLongClasspath.java: ensure -Xlog:class+path showing entire expecting app classpath
runtime/cds/appcds/UnusedCPDuringDump.java: non-empty dir in -cp should be fine during dump time if only classes from the system modules are being loaded even though some are defined to the PlatformClassLoader and AppClassLoader.
runtime/cds/appcds/VerifierTest_0.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_1A.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_1B.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_2.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifyObjArrayCloneTest.java:
runtime/cds/appcds/VerifyWithDefaultArchive.java: test default cds archive when turning on VerifySharedSpaces
runtime/cds/appcds/WideIloadTest.java: Test 'iload_w' bytecode in shared class
runtime/cds/appcds/WrongClasspath.java: classpath mismatch between dump time and execution time
runtime/cds/appcds/XShareAutoWithChangedJar.java: Test -Xshare:auto for AppCDS
runtime/cds/appcds/applications/JavacBench.java#dynamic: Run JavacBenchApp with the classic dynamic archive workflow
runtime/cds/appcds/applications/JavacBench.java#static: Run JavacBenchApp with the classic static archive workflow
runtime/cds/appcds/cacheObject/ArchivedIntegerCacheTest.java: Test primitive box caches integrity in various scenarios (IntegerCache etc)
runtime/cds/appcds/cacheObject/ArchivedModuleComboTest.java: Test archived system module sub-graph and verify objects are archived.
runtime/cds/appcds/cacheObject/ArchivedModuleCompareTest.java: Compare archived system modules with non-archived.
runtime/cds/appcds/cacheObject/ArchivedModuleWithCustomImageTest.java: Test archived module graph with custom runtime image
runtime/cds/appcds/cacheObject/CheckCachedMirrorTest.java: Test archived mirror
runtime/cds/appcds/cacheObject/CheckCachedResolvedReferences.java: Test resolved_references
runtime/cds/appcds/cacheObject/DifferentHeapSizes.java: Test automatic relocation of archive heap regions dur to heap size changes.
runtime/cds/appcds/cacheObject/DumpTimeVerifyFailure.java: Dump time should not crash if any class with shared strings fails verification due to missing dependencies.
runtime/cds/appcds/cacheObject/GCStressTest.java:
runtime/cds/appcds/cacheObject/HeapFragmentationTest.java: Relocate CDS archived regions to the top of the G1 heap
runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java: Test archived mirror with reference fields
runtime/cds/appcds/cacheObject/OpenArchiveRegion.java: Test open archive heap regions
runtime/cds/appcds/cacheObject/PrimitiveTypesTest.java: Test archived primitive type mirrors
runtime/cds/appcds/cacheObject/RedefineClassTest.java: Redefine shared class.
runtime/cds/appcds/cacheObject/VerifyArchivedFields.java: run with -XX:VerifyArchivedFields=2 for more expensive verification of the archived heap objects.
runtime/cds/appcds/condy/CondyHelloTest.java: Make sure CDS works with a minimal test case that uses a CONSTANT_Dynamic constant-pool entry
runtime/cds/appcds/customLoader/ClassListFormatA.java: Tests the format checking of class list format.
runtime/cds/appcds/customLoader/ClassListFormatB.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatC.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatD.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatE.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/HelloCustom.java: Hello World test for AppCDS custom loader support
runtime/cds/appcds/customLoader/HelloCustom_JFR.java: Same as HelloCustom, but add -XX:StartFlightRecording:dumponexit=true to the runtime options.
runtime/cds/appcds/customLoader/LoaderSegregationTest.java: Check that during dumping, the classes for BOOT/EXT/APP loaders are segregated from the custom loader classes.
runtime/cds/appcds/customLoader/OldClassAndInf.java: Test archiving of old class and interface with custom loader.
runtime/cds/appcds/customLoader/ParallelTestMultiFP.java: Load classes from CDS archive into multiple custom loader using parallel threads
runtime/cds/appcds/customLoader/ParallelTestSingleFP.java: Load classes from CDS archive into a single custom loader using parallel threads (finger print)
runtime/cds/appcds/customLoader/PrintSharedArchiveAndExit.java: test -XX:+PrintSharedArchiveAndExit output for shared class.
runtime/cds/appcds/customLoader/ProhibitedPackageNamesTest.java: Make sure prohibited packages cannot be stored into archive for custom loaders.
runtime/cds/appcds/customLoader/ProtectionDomain.java: AppCDS handling of protection domain in custom loaders.
runtime/cds/appcds/customLoader/SameNameInTwoLoadersTest.java: Testing the loading of a class with the same name in two different class loaders.
runtime/cds/appcds/customLoader/UnintendedLoadersTest.java: Make sure classes intended for custom loaders cannot be loaded by BOOT/EXT/APP loaders
runtime/cds/appcds/customLoader/UnloadUnregisteredLoaderTest.java: Test the behavior when shared classes loaded by custom loaders are unloaded.
runtime/cds/appcds/customLoader/UnsupportedPlatforms.java: Ensure that support for AppCDS custom class loaders are not enabled on unsupported platforms.
runtime/cds/appcds/dynamicArchive/AppendClasspath.java: At run time, it is OK to append new elements to the classpath that was used at dump time.
runtime/cds/appcds/dynamicArchive/ArchiveConsistency.java: Corrupt the header CRC fields of the top archive.
runtime/cds/appcds/dynamicArchive/ArchivedSuperIf.java: An archived super interface should be accessible by the class which implements the interface during runtime although the class itself is not in the CDS archive.
runtime/cds/appcds/dynamicArchive/ArrayKlasses.java: handling of the existence of InstanceKlass::array_klasses()
runtime/cds/appcds/dynamicArchive/BasicLambdaTest.java: Basic operations of Lambda class archiving.
runtime/cds/appcds/dynamicArchive/CDSStreamTestDriver.java: Run the CustomFJPoolTest in dynamic CDSarchive mode.
runtime/cds/appcds/dynamicArchive/ClassResolutionFailure.java: Test with a jar file which contains only the main class but not the dependent class.
runtime/cds/appcds/dynamicArchive/DoubleSumAverageTest.java:
runtime/cds/appcds/dynamicArchive/DynamicArchiveRelocationTest.java: Testing relocation of dynamic CDS archive (during both dump time and run time)
runtime/cds/appcds/dynamicArchive/DynamicFlag.java: The DynamicDumpShareSpaces flag is internal, setting it at the command line should have no effect.
runtime/cds/appcds/dynamicArchive/DynamicLambdaWithUseImplMethodHandle.java: CDS cannot archive lambda proxy with useImplMethodHandle
runtime/cds/appcds/dynamicArchive/DynamicLotsOfClasses.java: Try to archive lots of classes by searching for classes from the jrt:/ file system.
runtime/cds/appcds/dynamicArchive/ExcludedClasses.java: Unreferenced app classes during dump time should not be included in the archive.
runtime/cds/appcds/dynamicArchive/HelloDynamic.java: Hello World test for dynamic archive
runtime/cds/appcds/dynamicArchive/HelloDynamicCustom.java: Hello World test for dynamic archive with custom loader
runtime/cds/appcds/dynamicArchive/HelloDynamicCustomUnload.java: Hello World test for dynamic archive with custom loader.
runtime/cds/appcds/dynamicArchive/JFRDynamicCDS.java: Test dynamic CDS with JFR recording.
runtime/cds/appcds/dynamicArchive/JITInteraction.java: Test interaction with JIT threads during vm exit.
runtime/cds/appcds/dynamicArchive/LambdaContainsOldInf.java: VM should not crash during CDS dump when a lambda proxy class contains an old version of interface.
runtime/cds/appcds/dynamicArchive/LambdaCustomLoader.java: Lambda proxy class loaded by a custom class loader will not be archived.
runtime/cds/appcds/dynamicArchive/LambdaForClassInBaseArchive.java: Archive an base app class in a base archive and its lambda proxy class in a dynamic archive.
runtime/cds/appcds/dynamicArchive/LambdaInBaseArchive.java: Archive lambda proxy class is in the base archive.
runtime/cds/appcds/dynamicArchive/LambdaProxyCallerIsHidden.java: If the caller class of a lambda proxy class is a hidden class, the lambda proxy class will not be archived.
runtime/cds/appcds/dynamicArchive/LambdaProxyDuringShutdown.java: VM should not crash if a lambda proxy class is created during shutdown and its nest host is not linked.
runtime/cds/appcds/dynamicArchive/LinkClassTest.java: Classes loaded by the builtin class loaders should be linked during dynamic CDS dump time.
runtime/cds/appcds/dynamicArchive/MainModuleOnly.java: Test some scenarios with a main modular jar specified in the --module-path and -cp options in the command line.
runtime/cds/appcds/dynamicArchive/MethodSorting.java: When HelloA and HelloB are copied into the dynamic archive, the Symbols for their method's names will have a different sorting order.
runtime/cds/appcds/dynamicArchive/MismatchedBaseArchive.java: The base archive used for dynamic dump is not the same as the one used during run time.
runtime/cds/appcds/dynamicArchive/MissingArchive.java: error handling when either (or both) of the base/top archives are missing.
runtime/cds/appcds/dynamicArchive/NestTest.java: Archive a lambda proxy class created from a nested class.
runtime/cds/appcds/dynamicArchive/NoClassToArchive.java: A few edge cases where there's no class to be included in the dynamic archive.
runtime/cds/appcds/dynamicArchive/OldClassAndInf.java: Test archiving of old class and interface with custom loader with dynamic CDS.
runtime/cds/appcds/dynamicArchive/ParallelLambdaLoadTest.java: Test parallel loading of lambda proxy classes.
runtime/cds/appcds/dynamicArchive/PredicateTest.java:
runtime/cds/appcds/dynamicArchive/PrintSharedArchiveAndExit.java: Hello World test for dynamic archive with custom loader
runtime/cds/appcds/dynamicArchive/RegularHiddenClass.java: Hidden class not of type lambda proxy class will not be archived.
runtime/cds/appcds/dynamicArchive/RelativePath.java: Test relative paths specified in the -cp.
runtime/cds/appcds/dynamicArchive/SharedArchiveFileOption.java: Some negative tests for the SharedArchiveFile option
runtime/cds/appcds/dynamicArchive/SharedBaseAddressOption.java: Test how the dynamic archive handles -XX:SharedBaseAddress
runtime/cds/appcds/dynamicArchive/StaticInnerTest.java: Outer class is directly referenced during dump time but not during runtime.
runtime/cds/appcds/dynamicArchive/TestDynamicDumpAtOom.java: test dynamic dump with OOM
runtime/cds/appcds/dynamicArchive/TestDynamicRegenerateHolderClasses.java: LambHello World test for regenerate lambda holder classes in dynamic archive
runtime/cds/appcds/dynamicArchive/UnsupportedBaseArchive.java: unsupported base archive tests
runtime/cds/appcds/dynamicArchive/UnusedCPDuringDump.java: non-empty dir in -cp should be fine during dump time if only classes from the system modules are being loaded even though some are defined to the PlatformClassLoader and AppClassLoader.
runtime/cds/appcds/dynamicArchive/UsedAllArchivedLambdas.java: Test exhaustive use of archived lambda proxy classes.
runtime/cds/appcds/dynamicArchive/VerifyObjArrayCloneTest.java:
runtime/cds/appcds/dynamicArchive/VerifyWithDynamicArchive.java: test dynamic cds archive when turning on VerifySharedSpaces
runtime/cds/appcds/dynamicArchive/WrongTopClasspath.java: correct classpath for bottom archive, but bad classpath for top archive
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesAsCollectorTest.java: Run the MethodHandlesAsCollectorTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesCastFailureTest.java: Run the MethodHandlesCastFailureTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesGeneralTest.java: Run the MethodHandlesGeneralTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesInvokersTest.java: Run the MethodHandlesInvokersTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesPermuteArgumentsTest.java: Run the MethodHandlesPermuteArgumentsTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/dynamicArchive/methodHandles/MethodHandlesSpreadArgumentsTest.java: Run the MethodHandlesSpreadArgumentsTest.java test in dynamic CDS archive mode.
runtime/cds/appcds/javaldr/ArrayTest.java: test the ability to archive array classes and load them from the archive
runtime/cds/appcds/javaldr/ExceptionDuringDumpAtObjectsInitPhase.java: Out of memory When dumping the CDS archive
runtime/cds/appcds/javaldr/GCDuringDump.java: When dumping the CDS archive, try to cause garbage collection while classes are being loaded.
runtime/cds/appcds/javaldr/GCSharedStringsDuringDump.java: Similar to GCDuringDumping.java, this test adds the -XX:SharedArchiveConfigFile option for testing the interaction with GC and shared strings.
runtime/cds/appcds/javaldr/HumongousDuringDump.java: Test how CDS dumping handles the existence of humongous G1 regions.
runtime/cds/appcds/javaldr/LockDuringDump.java: When dumping the CDS archive, try to lock some objects.
runtime/cds/appcds/jigsaw/CheckUnsupportedDumpingOptions.java: Abort dumping if any of the new jigsaw vm options is specified.
runtime/cds/appcds/jigsaw/JigsawOptionsCombo.java: Test combinations of jigsaw options that affect the use of AppCDS
runtime/cds/appcds/jigsaw/NewModuleFinderTest.java: Make sure the archived module graph can co-exist with modules that are dynamically defined at runtime using the ModuleFinder API.
runtime/cds/appcds/jigsaw/PatchModule/AppClassInCP.java: a test to demonstrate that an application class in the -cp will be archived although --patch-module is specified.
runtime/cds/appcds/jigsaw/PatchModule/CustomPackage.java: if a class is defined to a package which is not defined to any module in the jimage, the class will not be found during dump time but it will be used during run time.
runtime/cds/appcds/jigsaw/PatchModule/MismatchedPatchModule.java: different settings of --patch-module at dump time and runtime are acceptable.
runtime/cds/appcds/jigsaw/PatchModule/PatchDir.java: a simple test to ensure that a directory in the --patch-module option does not affect dump process
runtime/cds/appcds/jigsaw/PatchModule/PatchJavaBase.java: sharing is disabled if java.base is patch at runtime
runtime/cds/appcds/jigsaw/PatchModule/Simple.java: a simple test to ensure that class is loaded from jar file in --patch-module at runtime
runtime/cds/appcds/jigsaw/PatchModule/SubClassOfPatchedClass.java: the class in the -cp is a subclass of the class in --patch-module.
runtime/cds/appcds/jigsaw/PatchModule/TwoJars.java: a patched class found in --patch-module should be used at runtime
runtime/cds/appcds/jigsaw/RedefineClassesInModuleGraph.java: Make sure that archived module graph is not loaded if critical classes have been redefined.
runtime/cds/appcds/jigsaw/classpathtests/BootAppendTests.java: AppCDS tests for testing -Xbootclasspath/a
runtime/cds/appcds/jigsaw/classpathtests/ClassPathTests.java: AppCDS tests for testing classpath/package conflicts
runtime/cds/appcds/jigsaw/classpathtests/DummyClassesInBootClassPath.java: Ensure that classes found in jimage takes precedence over classes found in -Xbootclasspath/a.
runtime/cds/appcds/jigsaw/classpathtests/EmptyClassInBootClassPath.java: Test a few scenarios if an empty class, which has the same name as the one in the jimage, is specified in the -Xbootclasspath/a 1) boot loader will always load the class from the bootclasspath 2) app loader will load the class from the jimage by default; app loader will load the class from the bootclasspath if the "--limit-modules java.base" option is specified
runtime/cds/appcds/jigsaw/modulepath/AddModules.java: sanity test the --add-modules option
runtime/cds/appcds/jigsaw/modulepath/AddOpens.java: sanity test the --add-opens option
runtime/cds/appcds/jigsaw/modulepath/AddReads.java: sanity test the --add-reads option
runtime/cds/appcds/jigsaw/modulepath/ExportModule.java: Tests involve exporting a module from the module path to a jar in the -cp.
runtime/cds/appcds/jigsaw/modulepath/JvmtiAddPath.java: JvmtiEnv::AddToBootstrapClassLoaderSearch and JvmtiEnv::AddToSystemClassLoaderSearch should disable AppCDS
runtime/cds/appcds/jigsaw/modulepath/MainModuleOnly.java: Test some scenarios with a main modular jar specified in the --module-path and -cp options in the command line.
runtime/cds/appcds/jigsaw/modulepath/ModulePathAndCP.java: 2 sets of tests: one with only --module-path in the command line; another with both -cp and --module-path in the command line.
runtime/cds/appcds/jigsaw/modulepath/ModulePathAndCP_JFR.java: Same as ModulePathAndCP, but add -XX:StartFlightRecording:dumponexit=true to the runtime options.
runtime/cds/appcds/jigsaw/modulepath/OptimizeModuleHandlingTest.java: test module path changes for optimization of module handling.
runtime/cds/appcds/jigsaw/overridetests/OverrideTests.java: AppCDS tests for overriding archived classes with -p and --upgrade-module-path
runtime/cds/appcds/jvmti/ClassFileLoadHookTest.java: Test jvmti class file loader hook interaction with AppCDS
runtime/cds/appcds/jvmti/InstrumentationTest.java: Exercise the java.lang.instrument.Instrumentation APIs on classes archived using CDS/AppCDSv1/AppCDSv2.
runtime/cds/appcds/jvmti/dumpingWithAgent/DumpingWithJavaAgent.java: CDS dumping with java agent.
runtime/cds/appcds/jvmti/dumpingWithAgent/DumpingWithJvmtiAgent.java: CDS dumping with JVMTI agent.
runtime/cds/appcds/jvmti/dumpingWithAgent/OldClassWithJavaAgent.java: Dump old class with java agent.
runtime/cds/appcds/jvmti/parallelLoad/ParallelLoadAndTransformTest.java: Load app classes from CDS archive in parallel threads, use initial transformation (CFLH)
runtime/cds/appcds/jvmti/transformRelatedClasses/TransformInterfaceImplementorAppCDS.java: Exercise initial transformation (class file loader hook) with CDS/AppCDS with Interface/Implementor pair
runtime/cds/appcds/jvmti/transformRelatedClasses/TransformSuperSubAppCDS.java: Exercise initial transformation (class file loader hook) with CDS/AppCDS with SubClass and SuperClass
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#custom-cl: Test class loader constraint checks for archived classes (dynamic archive) with custom class loader
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#custom-cl-zgc: Test dumptime_table entries are removed with zgc eager class unloading
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#default-cl: Test class loader constraint checks for archived classes (dynamic archive)
runtime/cds/appcds/loaderConstraints/LoaderConstraintsTest.java#custom-cl: Test class loader constraint checks for archived classes with custom class loader
runtime/cds/appcds/loaderConstraints/LoaderConstraintsTest.java#default-cl: Test class loader constraint checks for archived classes
runtime/cds/appcds/methodHandles/MethodHandlesAsCollectorTest.java: Run the MethodHandlesAsCollectorTest.java test in static CDS archive mode.
runtime/cds/appcds/methodHandles/MethodHandlesCastFailureTest.java: Run the MethodHandlesCastFailureTest.java test in static CDS archive mode.
runtime/cds/appcds/methodHandles/MethodHandlesGeneralTest.java: Run the MethodHandlesGeneralTest.java test in static CDS archive mode.
runtime/cds/appcds/methodHandles/MethodHandlesInvokersTest.java: Run the MethodHandlesInvokersTest.java test in static CDS archive mode.
runtime/cds/appcds/methodHandles/MethodHandlesPermuteArgumentsTest.java: Run the MethodHandlesPermuteArgumentsTest.java test in static CDS archive mode.
runtime/cds/appcds/methodHandles/MethodHandlesSpreadArgumentsTest.java: Run the MethodHandlesSpreadArgumentsTest.java test in static CDS archive mode.
runtime/cds/appcds/redefineClass/RedefineBasicTest.java: Run /serviceability/jvmti/RedefineClasses/RedefineRunningMethods in AppCDS mode to make sure class redefinition works with CDS.
runtime/cds/appcds/redefineClass/RedefineRunningMethods_Shared.java: Run /serviceability/jvmti/RedefineClasses/RedefineRunningMethods in AppCDS mode to make sure class redefinition works with CDS.
runtime/cds/appcds/sharedStrings/ExerciseGC.java: Exercise GC with shared strings
runtime/cds/appcds/sharedStrings/FlagCombo.java#id0: Test relevant combinations of command line flags with shared strings
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id0: Test options that are incompatible with use of shared strings Also test mismatch in oops encoding between dump time and run time
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id1:
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id2:
runtime/cds/appcds/sharedStrings/InternSharedString.java: Test shared strings together with string intern operation
runtime/cds/appcds/sharedStrings/InvalidFileFormat.java: Check most common errors in file format
runtime/cds/appcds/sharedStrings/LargePages.java: Basic shared string test with large pages
runtime/cds/appcds/sharedStrings/LockSharedStrings.java: Test locking on shared strings
runtime/cds/appcds/sharedStrings/ResolvedReferencesNotNullTest.java: Testing resolved references array to ensure elements are non-null
runtime/cds/appcds/sharedStrings/SharedStringsBasic.java: Basic test for shared strings
runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java: Basic plus test for shared strings
runtime/cds/appcds/sharedStrings/SharedStringsHumongous.java: Use a shared string allocated in a humongous G1 region.
runtime/cds/appcds/sharedStrings/SharedStringsStress.java: Write a lots of shared strings.
runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java: White box test for shared strings
runtime/cds/appcds/sharedStrings/SysDictCrash.java: Regression test for JDK-8098821
runtime/cds/serviceability/ReplaceCriticalClasses.java: Tests how CDS works when critical library classes are replaced with JVMTI ClassFileLoadHook
runtime/cds/serviceability/ReplaceCriticalClassesForSubgraphs.java: Tests how CDS works when critical library classes are replaced with JVMTI ClassFileLoadHook
runtime/cds/serviceability/transformRelatedClasses/TransformInterfaceAndImplementor.java: Exercise initial transformation (ClassFileLoadHook) with CDS with Interface/Implementor pair
runtime/cds/serviceability/transformRelatedClasses/TransformSuperAndSubClasses.java: Exercise initial transformation (ClassFileLoadHook) with CDS with SubClass and SuperClass
runtime/cds/serviceability/transformRelatedClasses/TransformSuperSubTwoPckgs.java: Exercise initial transformation (ClassFileLoadHook) with CDS with SubClass and SuperClass, each lives in own separate package
runtime/classFileParserBug/AccModuleTest.java: Throw NoClassDefFoundError if class access_flags have ACC_MODULE set
runtime/classFileParserBug/AnnotationTag.java: Fuzzy-ed RuntimeVisibleAnnotations causes assertion
runtime/classFileParserBug/BadInitMethod.java: VM prohibits <clinit> methods with return values
runtime/classFileParserBug/BadNameAndType.java: Constant pool NameAndType entries must point to non-zero length Utf8 strings
runtime/classFileParserBug/Bad_NCDFE_Msg.java: Check that the right message is displayed for NoClassDefFoundError exception.
runtime/classFileParserBug/Class53.jasm: Check that the JVM accepts class files with version 53
runtime/classFileParserBug/Class54.jasm: Check that the JVM accepts class files with version 54
runtime/classFileParserBug/Class55.jasm: Check that the JVM accepts class files with version 55
runtime/classFileParserBug/Class56.jasm: Check that the JVM accepts class files with version 56
runtime/classFileParserBug/ClassFileParserBug.java: Check for exception instead of assert.
runtime/classFileParserBug/EnclosingMethod.java: For InnerClasses attribute, VM permits inner_class_info_index value of zero
runtime/classFileParserBug/FakeMethodAcc.java: Skipping access check for classes generated by core reflection
runtime/classFileParserBug/InitInInterface.java: Check that any method named <init> in an interface causes ClassFormatError
runtime/classFileParserBug/TestBadClassName.java: Constant pool utf8 entry for class name cannot have empty qualified name '//'
runtime/classFileParserBug/TestBadPackageWithInterface.java: Check that if the VM rejects classes from packages starting with "java/", it will exit cleanly after InstanceKlass::verify_on(), and not leave freed memory in _local_interfaces.
runtime/classFileParserBug/TestEmptyBootstrapMethodsAttr.java: Test empty bootstrap_methods table within BootstrapMethods attribute
runtime/classFileParserBug/TestEmptyUnqName.java: Test that an unqualified name of "L;" causes a ClassFormatError exception.
runtime/classFileParserBug/UnknownAttrTest.java: Unknown attribute erroneously causes ClassFormatError exception.
runtime/clinit/ClassInitBarrier.java:
runtime/clone/AbstractClone.java: Check that invokeinterface of clone() works properly where clone() is an abstract method in a superinterface and also overridden locally.
runtime/clone/AbstractNoClones.jasm: Check that invokeinterface of clone() works properly where clone() is an abstract method in a superinterface and not overridden locally.
runtime/clone/DefaultClone.jasm: Check that a default method named clone() does not get masked by java.lang.Object.clone() during resolution.
runtime/clone/DefaultFinalize.jasm: Check that a default method named finalize() does not get masked by java.lang.Object.finalize() during resolution.
runtime/clone/DefaultHashCode.jasm: Check that invokeinterface calls the right hashCode() method when there is both a local method named hashCode() and a default method named hashCode().
runtime/clone/DefaultNoCloneInC.jasm: Check that calling clone() with an invokeinterface opcode throws an IAE even if there is a default method named clone() in a super interface.
runtime/clone/LocalClone.jasm: Check that method resolution for invokeinterface of clone() fails if it cannot find a public method named clone().
runtime/clone/NoClones.jasm: Check that a NoSuchMethodError exception gets thrown if invokeinterface calls clone() and there is no public implementation of clone().
runtime/clone/invokevirtual/HasLocalClone.jasm: Check that invokevirtual of clone() finds the clone() method that is local to the calling class.
runtime/clone/invokevirtual/NoLocalClone.jasm: Check that invokevirtual of clone() calls java.lang.Object.clone() even if a superinterface has a default method named clone().
runtime/clone/invokevirtual/NoLocalCloneAbstr.jasm: Check that invokevirtual of clone() calls java.lang.Object.clone() even if a superinterface has an abstract method named clone().
runtime/condy/BadBSMUseTest.java: CONSTANT_Dynamic_info structure's tries to use a BSM index whose signature is for an invokedynamic and vice versa.
runtime/condy/CondyBadBSMArrayTest.java: CONSTANT_Dynamic_info structure present with various bad BSM index, BSM array attribute checks.
runtime/condy/CondyBadNameTypeTest.java: CONSTANT_Dynamic_info structure's name_and_type_index item does not point at CONSANT_NameAndType_info
runtime/condy/CondyCFVCheckTest.java: CONSTANT_Dynamic_info structure present within an unsupported class file version.
runtime/condy/CondyLDCTest.java: Tests various ldc, ldc_w, ldc2_w instructions of CONSTANT_Dynamic.
runtime/condy/CondyNewInvokeSpecialTest.java: Test CONSTANT_Dynamic where the BSM is invoked via a REF_newInvokeSpecial.
runtime/condy/escapeAnalysis/TestEscapeCondy.java: Ensure escape analysis can handle an ldc of a dynamic constant whose return type is an array of boolean.
runtime/condy/staticInit/TestInitException.java: Correctly handle initialization error for Condy BSM.
runtime/contended/Basic.java: Support Contended Annotation - JEP 142
runtime/contended/DefaultValue.java: \@Contended: explicit default value behaves differently from the implicit value
runtime/contended/HasNonStatic.java: \@Contended: fix multiple issues in the layout code
runtime/contended/Inheritance1.java: \@Contended doesn't work correctly with inheritance
runtime/contended/OopMaps.java: \@Contended: fix multiple issues in the layout code
runtime/contended/OopMapsSameGroup.java: \@Contended within the same group to use the same oop map
runtime/contended/Options.java: ContendedPaddingWidth should be range-checked
runtime/duplAttributes/DuplAttributesTest.java: Throw exceptions when duplicate attributes are detected.
runtime/duplAttributes/TestDupSignatureAttr.java: Throw ClassFormatError exception for multiple Signature attributes
runtime/exceptionMsgs/AbstractMethodError/AbstractMethodErrorTest.java: Check that the verbose message of the AME is printed correctly.
runtime/exceptionMsgs/ArrayIndexOutOfBoundsException/ArrayIndexOutOfBoundsExceptionTest.java#id0: Test extended ArrayIndexOutOfBoundsException message.
runtime/exceptionMsgs/ArrayIndexOutOfBoundsException/ArrayIndexOutOfBoundsExceptionTest.java#id1:
runtime/exceptionMsgs/ArrayStoreException/ArrayStoreExceptionTest.java: Test ArrayStoreException message.
runtime/exceptionMsgs/IllegalAccessError/IllegalAccessErrorTest.java: Test messages of IllegalAccessError.
runtime/exceptionMsgs/IncompatibleClassChangeError/IncompatibleClassChangeErrorTest.java: Check that the verbose message of ICCE is printed correctly.
runtime/exceptionMsgs/NegativeArraySizeException/NegativeArraySizeExceptionTest.java: Test that NegativeArraySizeException reports the wrong size.
runtime/exceptionMsgs/NoClassDefFoundError/NoClassDefFoundErrorTest.java: Verifies message returned with NoClassDefFoundError exception.
runtime/exceptionMsgs/NullPointerException/NPEInHiddenTopFrameTest.java: Test NullPointerException messages thrown in frames that are hidden in the backtrace/stackTrace.
runtime/exceptionMsgs/NullPointerException/NullPointerExceptionTest.java#id0: Test extended NullPointerException message for classfiles generated with debug information.
runtime/exceptionMsgs/NullPointerException/NullPointerExceptionTest.java#id1: Test extended NullPointerException message for class files generated without debugging information.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id0: Test that the default of flag ShowCodeDetailsInExceptionMessages is 'true', i.e., make sure the VM does print the message by default.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id1: Test that the messages are suppressed if flag ShowCodeDetailsInExceptionMessages is 'false'.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id2: Test that the messages are printed if flag ShowCodeDetailsInExceptionMessages is 'true'.
runtime/exceptionMsgs/methodPrinting/TestPrintingMethods.java: Check that methods are printed properly.
runtime/execstack/TestCheckJDK.java: Searches for all libraries in test VM and checks that they have the noexecstack bit set.
runtime/execstack/Testexecstack.java: Stack guard pages lost after loading library with executable stack.
runtime/finalStatic/FinalStatic.java: Test that VerifyError is not thrown when 'overriding' a static method.
runtime/getSysPackage/GetPackageXbootclasspath.java: Test that getPackage() works with a class loaded via -Xbootclasspath/a.
runtime/getSysPackage/GetSysPkgTest.java:
runtime/handlerInTry/LoadHandlerInTry.java: JVM stuck in infinite loop during verification
runtime/handshake/AsyncHandshakeWalkStackTest.java:
runtime/handshake/HandshakeDirectTest.java: This test tries to stress direct handshakes between threads while suspending them.
runtime/handshake/HandshakeSuspendExitTest.java: This test tries to stress the handshakes with new and exiting threads while suspending them.
runtime/handshake/HandshakeWalkExitTest.java: This test tries to stress the handshakes with new and exiting threads
runtime/handshake/HandshakeWalkOneExitTest.java: This test tries to stress the handshakes with new and exiting threads
runtime/handshake/HandshakeWalkStackTest.java:
runtime/handshake/MixedHandshakeWalkStackTest.java:
runtime/handshake/SuspendBlocked.java:
runtime/interned/SanityTest.java: Sanity check of String.intern() & GC
runtime/invokedynamic/BootstrapMethodErrorTest.java: Test exceptions from invokedynamic and the bootstrap method
runtime/invokedynamic/MethodHandleConstantTest.java:
runtime/invokedynamic/TestDynamicConstant.java:
runtime/jni/8025979/UninitializedStrings.java: regression tests for 8025922, verify uninitialized strings reference.
runtime/jni/8033445/DefaultMethods.java: regression tests for 8033445, verify default methods call from JNI
runtime/jni/CallWithJNIWeak/CallWithJNIWeak.java: Test call of native function with JNI weak global ref.
runtime/jni/CalleeSavedRegisters/FPRegs.java:
runtime/jni/FastGetField/FastGetField.java: Tests that all FieldAccess notifications for Get*Field with primitive type are generated.
runtime/jni/FindClass/FindClassFromBoot.java: verify if the native library loaded by the boot loader can only find classes visible to the boot loader
runtime/jni/FindClassUtf8/FindClassUtf8.java: verify that -Xcheck:jni finds a bad utf8 name for class name.
runtime/jni/PrivateInterfaceMethods/PrivateInterfaceMethods.java: Add JNI invocation tests for private interface methods
runtime/jni/ReturnJNIWeak/ReturnJNIWeak.java: Test return of JNI weak global refs from native calls.
runtime/jni/ToStringInInterfaceTest/ToStringTest.java:
runtime/jni/abstractMethod/TestJNIAbstractMethod.java: Test that invocation of an abstract method from JNI works correctly
runtime/jni/atExit/TestAtExit.java: Check that attempting to use the JNI invocation API from an atexit handler fails as expected without crashing.
runtime/jni/checked/TestCheckedJniExceptionCheck.java: regression tests for 8164086, verify correct warning from checked JNI
runtime/jni/checked/TestCheckedReleaseArrayElements.java: verify multiple release calls on a copied array work when checked
runtime/jni/getCreatedJavaVMs/TestGetCreatedJavaVMs.java:
runtime/jni/nativeStack/TestNativeStack.java: Generate a JNI Fatal error, or a warning, in a launched VM and check the native stack is present as expected.
runtime/jni/registerNativesWarning/TestRegisterNativesWarning.java: Check that re-registering a native method of a boot class generates a warning when not done from a boot class
runtime/jni/terminatedThread/TestTerminatedThread.java: Basic test of Thread and ThreadMXBean queries on a natively attached thread that has failed to detach before terminating.
runtime/jsig/Testjsig.java: sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX
runtime/lambda-features/CyclicInterfaceInit.java: Interface initialization was crashing on this because the wrong class was getting initialization error.
runtime/lambda-features/InterfaceInitializationStates.java: Test interface initialization states and when certain interfaces are initialized in the presence of initialization errors.
runtime/lambda-features/InvokespecialInterface.java: [JDK 8] Test invokespecial and invokeinterface with the same JVM_CONSTANT_InterfaceMethodref
runtime/lambda-features/PublicStaticInterfaceMethodHandling.java: [JDK 8] Test correct handling of static public interface methods
runtime/lambda-features/TestConcreteClassWithAbstractMethod.java: method lookup on an abstract method in a concrete class should be successful
runtime/lambda-features/TestInterfaceInit.java: [JDK 8u40] Test interface init: only for interfaces declaring default methods, when subclass inits
runtime/lambda-features/TestInterfaceOrder.java: [JDK 8u40] Test interface initialization order
runtime/lambda-features/TestStaticandInstance.java: Test linkresolver search static, instance and overpass duplicates
runtime/linkResolver/InterfaceObjectTest.java: test interface resolution when clone and finalize are declared abstract within an interface and when they are not
runtime/linkResolver/TestDeletedMethod.java: Test that deleting a subclass method implementation results in execution of a superclass implementation - if it is accessible.
runtime/logging/BiasedLockingTest.java: -Xlog:biasedlocking should have logging from statements in the source code
runtime/logging/ClassInitializationTest.java:
runtime/logging/ClassLoadUnloadTest.java:
runtime/logging/ClassResolutionTest.java:
runtime/logging/CompressedOopsTest.java: -Xlog:gc+heap+coops=info should have output from the code
runtime/logging/CondyIndyTest.java: Test -Xlog:methodhandles with a test that contains both a condy and indy.
runtime/logging/DefaultMethodsTest.java: defaultmethods=debug should have logging from each of the statements in the code
runtime/logging/ExceptionsTest.java: exceptions=info output should have an exception message for interpreter methods
runtime/logging/LoaderConstraintsTest.java:
runtime/logging/ModulesTest.java: -Xlog:module should emit logging output
runtime/logging/MonitorInflationTest.java: monitorinflation=trace should have logging from each of the statements in the code
runtime/logging/MonitorMismatchTest.java:
runtime/logging/OsCpuLoggingTest.java: os+cpu output should contain some os,cpu information
runtime/logging/ProtectionDomainVerificationTest.java:
runtime/logging/RedefineClasses.java: Redefine classes with enabling logging to verify Klass:external_name() during GC.
runtime/logging/SafepointCleanupTest.java: safepoint+cleanup=info should have output from the code
runtime/logging/SafepointTest.java: safepoint=trace should have output from each log statement in the code
runtime/logging/StackWalkTest.java: -Xlog:stackwalk should produce logging from the source code
runtime/logging/StartupTimeTest.java: -Xlog:startuptime should produce logging from the source code
runtime/logging/TestMethodHandlesVerbose.java: Run simple test with -XX:+Verbose and -Xlog:methodhandles.
runtime/logging/ThreadLoggingTest.java: os+thread output should contain logging calls for thread start stop attaches detaches
runtime/logging/VMOperationTest.java: vmoperation=debug should have logging output
runtime/logging/VerificationTest.java: test enabling and disabling verification logging and verification log levels
runtime/logging/loadLibraryTest/LoadLibraryTest.java: Tests logging of shared library loads and unloads.
runtime/memory/LargePages/TestLargePagesFlags.java: Tests how large pages are choosen depending on the given large pages flag combinations.
runtime/memory/MultiAllocateNullCheck.java: multi_allocate() call does not CHECK_NULL and causes crash in fastdebug bits
runtime/memory/ReadFromNoaccessArea.java: Test that touching noaccess area in class ReservedHeapSpace results in SIGSEGV/ACCESS_VIOLATION
runtime/memory/ReadVMPageSize.java: Using WhiteBox to get VM page size
runtime/memory/ReserveMemory.java: Make sure reserved (but uncommitted) memory is not accessible
runtime/memory/StressVirtualSpaceResize.java: Stress test that expands/shrinks VirtualSpace
runtime/modules/AccModuleTest.java:
runtime/modules/AccessCheck/AccessExportTwice.java: Class p1.c1 in an unnamed module cannot read p2.c2 in module second_mod, even after p2 is exported to all unnamed.
runtime/modules/AccessCheck/AccessReadTwice.java: Class p1.c1 in module first_mod cannot read p2.c2 in module second_mod, even after a read edge is added between first_mod and second_mod.
runtime/modules/AccessCheck/CheckRead.java: Test that if module m1x can not read module m2x, then class p1.c1 in module m1x can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/DiffCL_CheckRead.java: Test that if module m1x can not read module m2x, then class p1.c1 in module m1x can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/DiffCL_ExpQualOther.java: Test that if module m1x can read module m2x, but package p2 in m2x is exported specifically to module m3x, then class p1.c1 in m1x can not access p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_ExpQualToM1.java: class p1.c1 defined in m1x tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/DiffCL_ExpUnqual.java: Test that if module m1x can read module m2x, and package p2 in m2x is exported unqualifiedly, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_PkgNotExp.java: Test that if module m1x can read module m2x, but package p2 in m2x is not exported, then class p1.c1 in m1x can not read p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_Umod.java: class p1.c1 defined in m1x tries to access p2.c2 defined in unnamed module.
runtime/modules/AccessCheck/DiffCL_UmodUpkg.java: class p3.c3 defined in module m1x tries to access c4 defined in an unnamed package and an unnamed module.
runtime/modules/AccessCheck/ExpQualOther.java: Test that if module m1x can read module m2x, but package p2 in m2x is exported specifically to module m3x, then class p1.c1 in m1x can not access p2.c2 in m2x.
runtime/modules/AccessCheck/ExpQualToM1.java: Test that if module m1x can read module m2x, AND package p2 in m2x is exported qualifiedly to m1x, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExpQualToM1PrivateMethodIAE.java: Test that if module m1x can read module m2x, AND package p2 in m2x is exported qualifiedly to m1x, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExpUnqual.java: Test that if module m1x can read module m2x, AND package p2 in module_two is exported unqualifiedly, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExportAllUnnamed.java: Test if package p2 in module m2x is exported to all unnamed, then class p1.c1 in an unnamed module can read p2.c2 in module m2x.
runtime/modules/AccessCheck/MethodAccessReadTwice.java: Test that invokedynamic instructions, that initially throw IAE exceptions because of a missing module read edge, behave correctly when executed after the module read edge is added.
runtime/modules/AccessCheck/PkgNotExp.java: Test that if module m1x can read module m2x, but package p2 in m2x is not exported, then class p1.c1 in m1x can not read p2.c2 in m2x.
runtime/modules/AccessCheck/Umod.java: class p1.c1 defined in m1x tries to access p2.c2 defined in unnamed module.
runtime/modules/AccessCheck/UmodDiffCL_ExpQualOther.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_ExpUnqual.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_PkgNotExp.java: class p1.c1 defined in unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_Umod.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in an unnamed module.
runtime/modules/AccessCheck/UmodDiffCL_UmodUpkg.java: class p3.c3 defined in a named package in an unnamed module tries to access c4 defined in an unnamed package in an unnamed module.
runtime/modules/AccessCheck/UmodUPkg.java: class p3.c3 defined in module m1x tries to access c4 defined in unnamed module.
runtime/modules/AccessCheck/UmodUpkgDiffCL_ExpQualOther.java: class c5 defined in an unnamed module tries to access p6.c6 defined in m2x.
runtime/modules/AccessCheck/UmodUpkgDiffCL_NotExp.java: class c5 in an unnamed module can read module m2x, but package p6 in module m2x is not exported.
runtime/modules/AccessCheck/UmodUpkgDiffCL_Umod.java: Test public type c5 defined in an unnamed package and unnamed module can access public type p6.c6 defined in an unnamed module.
runtime/modules/AccessCheck/UmodUpkg_ExpQualOther.java: Test that if class c5 in an unnamed module can read package p6 in module m2x, but package p6 in module m2x is exported qualifiedly to module m3x, then class c5 in an unnamed module can not read p6.c6 in module m2x.
runtime/modules/AccessCheck/UmodUpkg_NotExp.java: Test if package p6 in module m2x is not exported, then class c5 in an unnamed module can not access p6.c2 in module m2x.
runtime/modules/AccessCheck/UmodUpkg_Umod.java: Test public type c5 defined in an unnamed package and unnamed module can access public type p6.c6 defined in an unnamed module.
runtime/modules/AccessCheck/Umod_ExpQualOther.java: Test that if package p2 in module m2x is exported to module m3x, then class p1.c1 in an unnamed module can not read p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_ExpUnqual.java: Test if package p2 in module m2x is exported unqualifiedly, then class p1.c1 in an unnamed module can read p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_PkgNotExp.java: Test if package p2 in module m2x is not exported, then class p1.c1 in an unnamed module can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_UmodUpkg.java: class p3.c3 defined in an unnamed module tries to access c4 defined in an unnamed package and an unnamed module.
runtime/modules/AccessCheckAllUnnamed.java:
runtime/modules/AccessCheckExp.java:
runtime/modules/AccessCheckJavaBase.java:
runtime/modules/AccessCheckOpen.java:
runtime/modules/AccessCheckRead.java:
runtime/modules/AccessCheckSuper.java:
runtime/modules/AccessCheckUnnamed.java:
runtime/modules/AccessCheckWorks.java:
runtime/modules/CCE_module_msg.java:
runtime/modules/ClassLoaderNoUnnamedModuleTest.java: Ensure that if the JVM encounters a ClassLoader whose unnamedModule field is not set an InternalError results.
runtime/modules/ExportTwice.java:
runtime/modules/IgnoreModulePropertiesTest.java: Test that the VM ignores explicitly specified module internal properties.
runtime/modules/JVMAddModuleExportToAllUnnamed.java:
runtime/modules/JVMAddModuleExports.java:
runtime/modules/JVMAddModuleExportsToAll.java:
runtime/modules/JVMAddReadsModule.java:
runtime/modules/JVMDefineModule.java:
runtime/modules/LoadUnloadModuleStress.java: Ensure module information is cleaned when owning class loader unloads
runtime/modules/ModuleOptionsTest.java: Test that the VM only recognizes the last specified --list-modules options but accumulates --add-module values.
runtime/modules/ModuleOptionsWarn.java: Test warnings for ignored properties.
runtime/modules/ModuleStress/ExportModuleStressTest.java: package in the boot layer is repeatedly exported to unique module created in layers on top of the boot layer
runtime/modules/ModuleStress/ModuleStress.java: Test differing scenarios where a module's readability list and a package's exportability list should be walked
runtime/modules/ModuleStress/ModuleStressGC.java: layers over the boot layer are repeatedly created, during this iteration, GCs are forced to verify correct walk of module and package lists.
runtime/modules/ModulesSymLink.java: Test with symbolic linked lib/modules
runtime/modules/PatchModule/PatchModule2Dirs.java: Make sure --patch-module works with multiple directories.
runtime/modules/PatchModule/PatchModuleCDS.java: test that --patch-module works with CDS
runtime/modules/PatchModule/PatchModuleClassList.java: classes which are not useable during run time should not be included in the classlist
runtime/modules/PatchModule/PatchModuleDupJavaBase.java: VM exit initialization results if java.base is specificed more than once to --patch-module.
runtime/modules/PatchModule/PatchModuleDupModule.java: Module system initialization exception results if a module is specificed twice to --patch-module.
runtime/modules/PatchModule/PatchModuleJavaBase.java: Make sure --patch-module works for java.base.
runtime/modules/PatchModule/PatchModuleTest.java: Make sure --patch-module works for modules besides java.base.
runtime/modules/PatchModule/PatchModuleTestJar.java: Make sure --patch-module works when a jar file is specified for a module
runtime/modules/PatchModule/PatchModuleTestJarDir.java: Make sure --patch-module works when a jar file and a directory is specified for a module
runtime/modules/PatchModule/PatchModuleTraceCL.java: Make sure -Xlog:class+load=info works properly with "modules" jimage, --patch-module, and with -Xbootclasspath/a
runtime/modules/SealedInterfaceModuleTest.java:
runtime/modules/SealedModuleTest.java:
runtime/modules/Visibility/PatchModuleVisibility.java: Ensure that a newly introduced java.base package placed within the --patch-module directory is considered part of the boot loader's visibility boundary
runtime/modules/Visibility/XbootcpNoVisibility.java: Ensure that a class defined within a java.base package can not be located via -Xbootclasspath/a
runtime/modules/Visibility/XbootcpVisibility.java: Ensure that a package whose module has not been defined to the boot loader is correctly located with -Xbootclasspath/a
runtime/modules/getModuleJNI/GetModule.java: test JNI_GetModule() API
runtime/os/AvailableProcessors.java: Check that availableProcessors reports the correct value when running in a cpuset on linux
runtime/os/TestHugePageDecisionsAtVMStartup.java#Default: Test JVM large page setup (default options)
runtime/os/TestHugePageDecisionsAtVMStartup.java#LP_enabled: Test JVM large page setup (+LP)
runtime/os/TestHugePageDecisionsAtVMStartup.java#THP_enabled: Test JVM large page setup (+THP)
runtime/os/TestHugePageDetection.java: Test that the JVM detects the OS hugepage/THP settings correctly.
runtime/os/TestTimerSlack.java: Check that timer slack options work
runtime/os/TestTracePageSizes.java#compiler-options: Run test without segmented code cache.
runtime/os/TestTracePageSizes.java#explicit-large-page-size: Run test explicitly with both 2m and 1g pages on x64.
runtime/os/TestTracePageSizes.java#no-options: Run test with no arguments apart from the ones required by the test.
runtime/os/TestTracePageSizes.java#with-G1: Run tests with G1
runtime/os/TestTracePageSizes.java#with-Parallel: Run tests with Parallel
runtime/os/TestTracePageSizes.java#with-Serial: Run tests with Serial
runtime/os/TestTrimNative.java#testOffByDefault: Test that trimming is disabled by default
runtime/os/TestTrimNative.java#testOffExplicit: Test that trimming can be disabled explicitly
runtime/os/TestTrimNative.java#trimNative:
runtime/os/TestTrimNative.java#trimNativeHighInterval: High interval trimming should not even kick in for short program runtimes
runtime/os/TestTrimNative.java#trimNativeLowInterval: Very low (sub-second) interval, nothing should explode
runtime/os/TestUseCpuAllocPath.java: If #processors > 1024 os_linux.cpp uses special coding.
runtime/records/RedefineRecord.java: Test that a class that is a record can be redefined.
runtime/records/recordAttributeTest.java:
runtime/records/recordReflectionTest.java: testing reflection APIs for record classes
runtime/reflect/ArrayGetIntException.java: (reflect) Misleading detail string in IllegalArgumentException thrown by Array.get<Type>
runtime/reflect/ReflectStackOverflow.java: This program crashes in 1.1, but runs okay in 1.2.
runtime/sealedClasses/GetPermittedSubclassesTest.java:
runtime/sealedClasses/OverrideSealedTest.java:
runtime/sealedClasses/RedefinePermittedSubclass.java: Test that a permitted subclass, that is resolved by its super class, can be redefined.
runtime/sealedClasses/RedefineSealedClass.java: Test that a class that is a sealed class can be redefined.
runtime/sealedClasses/SealedUnnamedModuleIntfTest.java:
runtime/sealedClasses/SealedUnnamedModuleTest.java:
runtime/stackMapCheck/StackMapCheck.java: Class verifier accepts an invalid class file
runtime/strictfp/StrictfpModifierChecksTest.java:
runtime/stringtable/StringTableCleaningTest.java: Stress the string table and cleaning.
runtime/stringtable/StringTableVerifyTest.java: VerifyStringTableAtExit should not crash
runtime/verifier/InvokeClone.java:
runtime/verifier/OverriderMsg.java:
runtime/verifier/PrimIntArray.java: Throw VerifyError when checking assignability of primitive arrays that are not identical.
runtime/verifier/PutfieldProtectedTest.java: Make sure error message for protected putfield error is correct.
runtime/verifier/ReturnMsgs.java: Test that VerifyError messages are correct when return bytecodes andd method signatures do not match.
runtime/verifier/TestANewArray.java: Test that anewarray bytecode is valid only if it specifies 254 or fewer dimensions.
runtime/verifier/TestMultiANewArray.java:
runtime/verifier/TestSigParse.java: Test that signatures are properly parsed when verification of local classes is requested but verification of remote classes is not.
runtime/verifier/TestStaticIF.java: Test static interface method.
runtime/verifier/TraceClassRes.java: split verifier needs to add class resolution tracing
runtime/verifier/VerifyProtectedConstructor.java: Verify that protected constructor calls are not allowed for any classfile versions in either verifier.
runtime/verifier/VerifyStackForExceptionHandlers.java: Verify that methods with max_stack==0 don't have exception handlers
runtime/verifier/defaultMethods/DefaultMethodRegressionTests.java: defaultMethod resolution and verification
runtime/verifier/defaultMethods/DefaultMethodRegressionTestsRun.java: defaultMethod resolution and verification using an URLClassLoader
runtime/verifier/popTopTests/PopDupTop.java: Throw VerifyError when popping a stack element of TOP
runtime/verifier/stackMapTableTests/StackMapTableTest.java: Test that the JVM does not assert when printing a stack map table containing a stack map with a bad verification type.
runtime/whitebox/TestHiddenClassIsAlive.java: Test that Whitebox.isClassAlive() works with hidden classes.
runtime/whitebox/TestWBDeflateIdleMonitors.java: Test to verify that WB method deflateIdleMonitors works correctly.
runtime/whitebox/WBStackSize.java: verify that whitebox functions getThreadFullStackSize() and getThreadRemainingStackSize are working
sanity/BasicVMTest.java: make sure various basic java options work
serviceability/7170638/SDTProbesGNULinuxTest.java: Test SDT probes available on GNU/Linux when DTRACE_ENABLED
serviceability/AsyncGetCallTrace/MyPackage/ASGCTBaseTest.java: Verifies that AsyncGetCallTrace is call-able and provides sane information.
serviceability/ParserTest.java: Test that the diagnostic command arguemnt parser works
serviceability/attach/AttachNegativePidTest.java:
serviceability/attach/AttachSetGetFlag.java: Tests the setFlag and printFlag attach command
serviceability/attach/AttachWithStalePidFile.java: Regression test for attach issue where stale pid files in /tmp lead to connection issues
serviceability/attach/ConcAttachTest.java:
serviceability/attach/RemovingUnixDomainSocketTest.java:
serviceability/dcmd/compiler/CodeCacheTest.java: Test of diagnostic command Compiler.codecache
serviceability/dcmd/compiler/CodeHeapAnalyticsParams.java: Test the Compiler.CodeHeap_Analytics command
serviceability/dcmd/compiler/CodelistTest.java: Test of diagnostic command Compiler.codelist Flag comment: -XX:-UseCodeCacheFlushing - to prevent methods from being removed from the code cache before we have checked the results This test should never run in the same VM as other tests - the code cache may get huge which will create an enormous amount of output to parse.
serviceability/dcmd/compiler/CompilerDirectivesDCMDTest.java: Test of diagnostic command
serviceability/dcmd/compiler/CompilerQueueTest.java: Test of diagnostic command Compiler.queue
serviceability/dcmd/compiler/PerfMapTest.java: Test of diagnostic command Compiler.perfmap
serviceability/dcmd/framework/HelpTest.java: Test of diagnostic command help (tests all DCMD executors)
serviceability/dcmd/framework/InvalidCommandTest.java: Test of invalid diagnostic command (tests all DCMD executors)
serviceability/dcmd/framework/VMVersionTest.java: Test of diagnostic command VM.version (tests all DCMD executors)
serviceability/dcmd/gc/ClassHistogramTest.java: Test of diagnostic command GC.class_histogram
serviceability/dcmd/gc/FinalizerInfoTest.java:
serviceability/dcmd/gc/HeapDumpAllTest.java: Test of diagnostic command GC.heap_dump -all=true
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id0: Test of diagnostic command GC.heap_dump with gzipped output (Serial GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id1: Test of diagnostic command GC.heap_dump with gzipped output (Parallel GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id2: Test of diagnostic command GC.heap_dump with gzipped output (G1 GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id3: Test of diagnostic command GC.heap_dump with gzipped output (Z GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id4: Test of diagnostic command GC.heap_dump with gzipped output (Shenandoah GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#id5: Test of diagnostic command GC.heap_dump with gzipped output (Epsilon GC)
serviceability/dcmd/gc/HeapDumpTest.java: Test of diagnostic command GC.heap_dump
serviceability/dcmd/gc/HeapInfoTest.java: Test of diagnostic command GC.heap_info
serviceability/dcmd/gc/RunGCTest.java: Test of diagnostic command GC.run
serviceability/dcmd/jvmti/AttachFailed/AttachIncorrectLibrary.java:
serviceability/dcmd/jvmti/AttachFailed/AttachNoEntry.java:
serviceability/dcmd/jvmti/AttachFailed/AttachReturnError.java:
serviceability/dcmd/jvmti/DataDumpDcmdTest.java: Test of JVMTI.data_dump diagnostic command
serviceability/dcmd/jvmti/LoadAgentDcmdTest.java:
serviceability/dcmd/thread/PrintConcurrentLocksTest.java: Test of diagnostic command Thread.print -l=true
serviceability/dcmd/thread/PrintTest.java: Test of diagnostic command Thread.print
serviceability/dcmd/vm/ClassHierarchyTest.java: Test of diagnostic command VM.class_hierarchy
serviceability/dcmd/vm/ClassLoaderHierarchyTest.java: Test of diagnostic command VM.classloaders
serviceability/dcmd/vm/ClassLoaderStatsTest.java: Test of diagnostic command VM.classloader_stats
serviceability/dcmd/vm/CommandLineTest.java: Test of diagnostic command VM.command_line
serviceability/dcmd/vm/DynLibsTest.java: Test of VM.dynlib diagnostic command via MBean
serviceability/dcmd/vm/EventsTest.java: Test of diagnostic command VM.events
serviceability/dcmd/vm/FlagsTest.java: Test of diagnostic command VM.flags
serviceability/dcmd/vm/SetVMFlagTest.java: Test of VM.set_flag diagnostic command
serviceability/dcmd/vm/ShowReflectionTargetTest.java: Test that various diagnostic commands which can show core reflection invocation targets do so correctly (See: JDK-8203343).
serviceability/dcmd/vm/SystemPropertiesTest.java: Test of diagnostic command VM.system_properties
serviceability/dcmd/vm/TrimLibcHeapTest.java: Test of diagnostic command VM.trim_libc_heap
serviceability/dcmd/vm/UptimeTest.java: Test of diagnostic command VM.uptime
serviceability/dtrace/DTraceOptionsTest.java#enabled: Test DTrace options are accepted on suitable builds
serviceability/jdwp/AllModulesCommandTest.java: Tests the modules-related JDWP commands
serviceability/jvmti/8036666/GetObjectLockCount.java: verify jvm returns correct lock recursion count
serviceability/jvmti/AddModuleExportsAndOpens/MyPackage/AddModuleExportsAndOpensTest.java: Verifies the JVMTI AddModuleExports and AddModuleOpens API
serviceability/jvmti/AddModuleReads/MyPackage/AddModuleReadsTest.java: Verifies the JVMTI AddModuleReads API
serviceability/jvmti/AddModuleUsesAndProvides/MyPackage/AddModuleUsesAndProvidesTest.java: Basic test for JVMTI AddModuleUses and AddModuleProvides
serviceability/jvmti/CanGenerateAllClassHook/CanGenerateAllClassHook.java: Tests that jvmtiEnv::GetPotentialCapabilities reports can_generate_all_class_hook_events capability with CDS (-Xshare:on) at ONLOAD and LIVE phases
serviceability/jvmti/CompiledMethodLoad/Zombie.java: Generate compiled method load events without crashing
serviceability/jvmti/DynamicCodeGenerated/DynamicCodeGeneratedTest.java: Test concurrent enabling and posting of DynamicCodeGenerated events.
serviceability/jvmti/FieldAccessWatch/FieldAccessWatch.java: Tests that all FieldAccess and FieldModification notifications are generated.
serviceability/jvmti/FollowReferences/FieldIndices/FieldIndicesTest.java: The test verifies heap walking API (FollowReferences) reports field indeces in correct order (as described by jvmtiHeapReferenceInfoField spec).
serviceability/jvmti/GenerateEvents/MyPackage/GenerateEventsTest.java: Send CompiledMethodLoad events only to the environment requested it with GenerateEvents
serviceability/jvmti/GetClassMethods/OverpassMethods.java: GetClassMethods is confused by the presence of default methods in super interfaces
serviceability/jvmti/GetLocalVariable/GetLocalVars.java: VM_GetOrSetLocal doesn't check local slot type against requested type
serviceability/jvmti/GetLocalVariable/GetLocalWithoutSuspendTest.java: Test if stack walk to get local variable in the JVMTI implementation is safe if the target thread is not suspended.
serviceability/jvmti/GetMethodDeclaringClass/TestUnloadedClass.java: Stress test GetMethodDeclaringClass
serviceability/jvmti/GetModulesInfo/JvmtiGetAllModulesTest.java: Verifies the JVMTI GetAllModules API
serviceability/jvmti/GetNamedModule/MyPackage/GetNamedModuleTest.java: Verifies the JVMTI GetNamedModule API
serviceability/jvmti/GetObjectSizeClass.java: JvmtiEnv::GetObjectSize reports incorrect java.lang.Class instance size
serviceability/jvmti/GetOwnedMonitorInfo/GetOwnedMonitorInfoTest.java: Checks that a contended monitor does not show up in the list of owned monitors
serviceability/jvmti/GetOwnedMonitorInfo/GetOwnedMonitorInfoWithEATest.java: Test JVMTI's GetOwnedMonitorInfo with scalar replaced objects and eliminated locks on stack (optimizations based on escape analysis).
serviceability/jvmti/GetOwnedMonitorStackDepthInfo/GetOwnedMonitorStackDepthInfoTest.java: Need to cover JVMTI's GetOwnedMonitorStackDepthInfo function
serviceability/jvmti/GetOwnedMonitorStackDepthInfo/GetOwnedMonitorStackDepthInfoWithEATest.java: Test JVMTI's GetOwnedMonitorStackDepthInfo with scalar replaced objects and eliminated locks on stack (optimizations based on escape analysis).
serviceability/jvmti/GetSystemProperty/JvmtiGetSystemPropertyTest.java: Verifies the JVMTI GetSystemProperty API returns the updated java.vm.info value
serviceability/jvmti/GetThreadListStackTraces/OneGetThreadListStackTraces.java: Verifies JVMTI GetThreadListStackTraces API with thread_count = 1
serviceability/jvmti/Heap/IterateHeapWithEscapeAnalysisEnabled.java: JVMTI agents can obtain references to not escaping objects using JVMTI Heap functions.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorArrayAllSampledTest.java: Verifies the JVMTI Heap Monitor interval when allocating arrays.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorEventOnOffTest.java: Verifies if turning off the event notification stops events.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCParallelTest.java: Verifies the JVMTI Heap Monitor Statistics using ParallelGc
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCSerialTest.java: Verifies the JVMTI Heap Monitor Statistics using SerialGC
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCTest.java: Verifies the default GC with the Heap Monitor event system.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorIllegalArgumentTest.java: Verifies the JVMTI SetHeapSamplingInterval returns an illegal argument for negative ints.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInitialAllocationTest.java: Verifies the JVMTI Heap Monitor does not always sample the first object.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInterpreterArrayTest.java: Verifies the JVMTI Heap Monitor using the interpreter.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInterpreterObjectTest.java: Verifies the JVMTI Heap Monitor using the interpreter.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorMultiArrayTest.java: Verifies the JVMTI Heap Monitor API when allocating a multi-array.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorNoCapabilityTest.java: Verifies the JVMTI Heap Monitor does not work without the required capability.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorRecursiveTest.java: Verifies the JVMTI Heap Monitor API does not do infinite recursion.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatArrayCorrectnessTest.java: Verifies the JVMTI Heap Monitor interval when allocating arrays.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatIntervalTest.java: Verifies the JVMTI Heap Monitor sampling interval average.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatObjectCorrectnessTest.java: Verifies the JVMTI Heap Monitor sampling via object allocation.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatSimpleTest.java: Verifies the JVMTI Heap Monitor events are only sent after enabling.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorTest.java: Verifies the JVMTI Heap Monitor API
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadDisabledTest.java: Verifies the JVMTI Heap Monitor Thread can disable events for a given thread.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadOnOffTest.java: Verifies the JVMTI Heap Monitor Thread sanity.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadTest.java: Verifies the JVMTI Heap Monitor Thread information sanity.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorTwoAgentsTest.java: Verifies the JVMTI Heap Monitor does not work with two agents.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorVMEventsTest.java: Verifies that when the VM event is sent, sampled events are also collected.
serviceability/jvmti/HiddenClass/P/Q/HiddenClassSigTest.java:
serviceability/jvmti/IsModifiableModule/MyPackage/IsModifiableModuleTest.java: Verifies the JVMTI IsModifiableModule API
serviceability/jvmti/ModuleAwareAgents/ClassFileLoadHook/MAAClassFileLoadHook.java:
serviceability/jvmti/ModuleAwareAgents/ClassLoadPrepare/MAAClassLoadPrepare.java: Verify ClassLoad and ClassPrepare JVMTI event with and without can_generate_early_vmstart capability
serviceability/jvmti/ModuleAwareAgents/ThreadStart/MAAThreadStart.java: Verify ThreadStart JVMTI event with can_generate_early_vmstart capability
serviceability/jvmti/NotifyFramePop/NotifyFramePopTest.java: Verifies NotifyFramePop request is cleared if JVMTI_EVENT_FRAME_POP is disabled
serviceability/jvmti/RedefineClasses/ClassVersionAfterRedefine.java: Class redefinition with a different class file version
serviceability/jvmti/RedefineClasses/ModifyAnonymous.java: Test that retransforming and redefining anonymous classes gets UnmodifiableClassException
serviceability/jvmti/RedefineClasses/RedefineAddLambdaExpression.java: Redefine a class' public static method that contains a lambda expression
serviceability/jvmti/RedefineClasses/RedefineAnnotations.java: Test that type annotations are retained after a retransform
serviceability/jvmti/RedefineClasses/RedefineDoubleDelete.java: Redefine class with CFLH twice to test deleting the cached_class_file
serviceability/jvmti/RedefineClasses/RedefineFinalizer.java: Don't assert if we redefine finalize method
serviceability/jvmti/RedefineClasses/RedefineGenericSignatureTest.java: Verifies class redefinition correctly updates generic_signature and source_file_name attributes
serviceability/jvmti/RedefineClasses/RedefineInterfaceCall.java: Redefine class with interface method call
serviceability/jvmti/RedefineClasses/RedefineInterfaceMethods.java: Redefine private and default interface methods
serviceability/jvmti/RedefineClasses/RedefineLeak.java: Test that redefinition reuses metaspace blocks that are freed
serviceability/jvmti/RedefineClasses/RedefineObject.java: Ensure Object natives stay registered after redefinition
serviceability/jvmti/RedefineClasses/RedefinePreviousVersions.java: Test clean_previous_versions flag and processing during class unloading.
serviceability/jvmti/RedefineClasses/RedefineRunningMethods.java: Redefine EMCP and non-EMCP methods that are running in an infinite loop
serviceability/jvmti/RedefineClasses/RedefineRunningMethodsWithBacktrace.java: Get old method's stack trace elements after GC
serviceability/jvmti/RedefineClasses/RedefineRunningMethodsWithResolutionErrors.java: Redefine running methods that have cached resolution errors
serviceability/jvmti/RedefineClasses/RedefineSharedClassJFR.java: Verify should_clean_previous_versions when run with JFR and CDS
serviceability/jvmti/RedefineClasses/RedefineSubtractLambdaExpression.java: Redefine a class' public static method that contains a lambda expression
serviceability/jvmti/RedefineClasses/RetransformClassesZeroLength.java: Instrumentation.retransformClasses(new Class[0]) should be NOP
serviceability/jvmti/RedefineClasses/TestAddDeleteMethods.java: RI does not follow the JVMTI RedefineClasses spec; need to disallow adding and deleting methods
serviceability/jvmti/RedefineClasses/TestLambdaFormRetransformation.java: JSR 292: constant pool reconstitution must support pseudo strings
serviceability/jvmti/RedefineClasses/TestMultipleClasses.java: Scalability problem with redefinition - multiple code cache walks
serviceability/jvmti/RedefineClasses/TestRedefineCondy.java: Test redefining a class with a condy in its constant pool
serviceability/jvmti/RedefineClasses/TestRedefineObject.java:
serviceability/jvmti/RedefineClasses/TestRedefineWithUnresolvedClass.java: Redefine a class with an UnresolvedClass reference in the constant pool.
serviceability/jvmti/RedefineClasses/TransformerDeadlockTest.java: Test recursively retransforms the same class.
serviceability/jvmti/SetBreakpoint/TestManyBreakpoints.java:
serviceability/jvmti/StartPhase/AllowedFunctions/AllowedFunctions.java: Verify the functions that are allowed to operate in the start phase with and without can_generate_early_vmstart capability.
serviceability/jvmti/SuspendWithCurrentThread/SuspendWithCurrentThread.java: [TEST] develop a test case for SuspendThreadList including current thread
serviceability/jvmti/SuspendWithObjectMonitorEnter/SuspendWithObjectMonitorEnter.java: Test SuspendThread with ObjectMonitor enter.
serviceability/jvmti/SuspendWithObjectMonitorWait/SuspendWithObjectMonitorWait.java: Test SuspendThread with ObjectMonitor wait.
serviceability/jvmti/SuspendWithRawMonitorEnter/SuspendWithRawMonitorEnter.java: Test SuspendThread with RawMonitor enter.
serviceability/jvmti/VMEvent/MyPackage/VMEventRecursionTest.java: Verifies that a VM event callback does not recurse if a VM object is allocated during callback.
serviceability/jvmti/thread/GetStackTrace/GetStackTraceAndRetransformTest/GetStackTraceAndRetransformTest.java: Test that a sequence of method retransformation and stacktrace capture while the old method version is still on stack does not lead to a crash when that method's jmethodID is used as an argument for JVMTI functions.
serviceability/logging/TestBasicLogOutput.java: Ensure logging can be enabled and successfully prints to stdout.
serviceability/logging/TestDefaultLogOutput.java: Ensure logging is default on stdout.
serviceability/logging/TestFullNames.java: Ensure proper parsing of unquoted full output names for -Xlog arguments.
serviceability/logging/TestLogRotation.java: test flags for log rotation
serviceability/logging/TestMultipleXlogArgs.java: Ensure multiple -Xlog arguments aggregate the logging options.
serviceability/logging/TestQuotedLogOutputs.java: Ensure proper parsing of quoted output names for -Xlog arguments.
serviceability/monitoring/ThreadInfo/GetLockOwnerName/GetLockOwnerName.java: The test checks that ThreadInfo.getLockOwnerName() returns a non-null string for a blocked thread and then makes repeated calls to getThreadInfo() and ThreadInfo.getLockOwnerName() until the thread has exited.
serviceability/threads/TestFalseDeadLock.java: Make sure no deadlock is reported for this program which has no deadlocks.
serviceability/tmtools/jstack/DaemonThreadTest.java: Create daemon and non-deamon threads.
serviceability/tmtools/jstack/JstackThreadTest.java: jstack doesn't close quotation marks properly with threads' name greater than 1996 characters
serviceability/tmtools/jstack/SpreadLockTest.java: Create a thread which stops in methods a(), a()->b(), a()->b()->c(), synchronizing on one monitor inside of each method.
serviceability/tmtools/jstack/ThreadNamesTest.java: Checks that jstack correctly prints the thread names
serviceability/tmtools/jstack/TraveledLockTest.java: Create a thread which stops in methods a(), a()->b(), a()->b()->c(), synchronizing on one monitor inside of each method.
serviceability/tmtools/jstack/WaitNotifyThreadTest.java: Call Object.wait() method.
serviceability/tmtools/jstat/GcCapacityTest.java: Test checks the consistency of the output displayed with jstat -gccapacity.
serviceability/tmtools/jstat/GcCauseTest01.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcCauseTest02.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcCauseTest03.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcNewTest.java: Test checks output displayed with jstat -gcnew.
serviceability/tmtools/jstat/GcTest01.java: Test checks output displayed with jstat -gc.
serviceability/tmtools/jstat/GcTest02.java: Test checks output displayed with jstat -gc.

Skipped: jtreg.SkippedException: Base64 intrinsic is not available

compiler/intrinsics/base64/TestBase64.java: tests java.util.Base64

Skipped: jtreg.SkippedException: Could not find lsof like command

runtime/8176717/TestInheritFD.java: a new process should not inherit open file descriptors

Skipped: jtreg.SkippedException: SA Attach not expected to work. Ptrace attach not supported.

serviceability/sa/CDSJMapClstats.java: Test the jhsdb jmap -clstats command with CDS enabled
serviceability/sa/ClhsdbAttach.java: Test clhsdb attach, detach, reattach commands
serviceability/sa/ClhsdbAttachDifferentJVMs.java: Test clhsdb attach, detach, and then attach to different JVM
serviceability/sa/ClhsdbCDSJstackPrintAll.java: Test the clhsdb commands 'jstack', 'printall', 'where' with CDS enabled
serviceability/sa/ClhsdbClasses.java: Test clhsdb class and classes commands
serviceability/sa/ClhsdbDumpclass.java: Test clhsdb dumpclass command
serviceability/sa/ClhsdbDumpheap.java: Test clhsdb dumpheap command
serviceability/sa/ClhsdbField.java: Test clhsdb 'field' command
serviceability/sa/ClhsdbFindPC.java#id0: Test the clhsdb 'findpc' command with Xcomp on live process
serviceability/sa/ClhsdbFindPC.java#id2: Test the clhsdb 'findpc' command w/o Xcomp on live process
serviceability/sa/ClhsdbFlags.java: Test clhsdb flags command
serviceability/sa/ClhsdbHistory.java: Test clhsdb command line history support
serviceability/sa/ClhsdbInspect.java: Test the clhsdb 'inspect' command
serviceability/sa/ClhsdbJdis.java: Test the clhsdb 'jdis' command
serviceability/sa/ClhsdbJhisto.java: Test clhsdb jhisto command
serviceability/sa/ClhsdbJstack.java#id0: Test clhsdb Jstack command
serviceability/sa/ClhsdbJstack.java#id1: Test clhsdb Jstack command
serviceability/sa/ClhsdbJstackXcompStress.java:
serviceability/sa/ClhsdbLongConstant.java: Test clhsdb longConstant command
serviceability/sa/ClhsdbPmap.java#id0: Test clhsdb pmap command on a live process
serviceability/sa/ClhsdbPrintAll.java: Test clhsdb 'printall' command
serviceability/sa/ClhsdbPrintAs.java: Test the clhsdb 'printas' command
serviceability/sa/ClhsdbPrintStatics.java: Test clhsdb printstatics command
serviceability/sa/ClhsdbPstack.java#id0: Test clhsdb pstack command on a live process
serviceability/sa/ClhsdbScanOops.java#id0: Test the clhsdb 'scanoops' command
serviceability/sa/ClhsdbScanOops.java#id1: Test the clhsdb 'scanoops' command
serviceability/sa/ClhsdbSource.java: Test clhsdb source command
serviceability/sa/ClhsdbSymbol.java: Test the clhsdb 'symbol' command on live process
serviceability/sa/ClhsdbThread.java: Test clhsdb 'thread' and 'threads' commands
serviceability/sa/ClhsdbVmStructsDump.java: Test clhsdb 'vmstructsdump' command
serviceability/sa/ClhsdbWhere.java: Test clhsdb where command
serviceability/sa/DeadlockDetectionTest.java: Test deadlock detection
serviceability/sa/JhsdbThreadInfoTest.java:
serviceability/sa/TestClassDump.java: Test ClassDump tool
serviceability/sa/TestClhsdbJstackLock.java:
serviceability/sa/TestCpoolForInvokeDynamic.java:
serviceability/sa/TestDefaultMethods.java:
serviceability/sa/TestG1HeapRegion.java:
serviceability/sa/TestHeapDumpForInvokeDynamic.java:
serviceability/sa/TestInstanceKlassSize.java:
serviceability/sa/TestInstanceKlassSizeForInterface.java:
serviceability/sa/TestIntConstant.java: Test the 'intConstant' command of jhsdb clhsdb.
serviceability/sa/TestJhsdbJstackLineNumbers.java:
serviceability/sa/TestJhsdbJstackLock.java:
serviceability/sa/TestJhsdbJstackMixed.java:
serviceability/sa/TestObjectAlignment.java:
serviceability/sa/TestObjectMonitorIterate.java:
serviceability/sa/TestPrintMdo.java:
serviceability/sa/TestSysProps.java: Test "jhsdb jinfo --sysprops", "jinfo -sysprops", and clhsdb "sysprops" commands
serviceability/sa/TestType.java: Test the 'type' command of jhsdb clhsdb.
serviceability/sa/TestUniverse.java: Test the 'universe' command of jhsdb clhsdb.
serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java: Regression test for hprof export issue due to large heaps (>2G)
serviceability/sa/sadebugd/ClhsdbAttachToDebugServer.java: Test clhsdb connect, detach, reattach commands
serviceability/sa/sadebugd/ClhsdbTestConnectArgument.java:
serviceability/sa/sadebugd/DebugdConnectTest.java: Checks ability for connecting to debug server (jstack, jmap, jinfo, jsnap)
serviceability/sa/sadebugd/DisableRegistryTest.java: Test to use already started RMI registry
serviceability/sa/sadebugd/PmapOnDebugdTest.java:
serviceability/sa/sadebugd/RunCommandOnServerTest.java: Test clhsdb command which should be run on debugd server
serviceability/sa/sadebugd/SADebugDTest.java: Checks that the jshdb debugd utility successfully starts and tries to attach to a running process

Skipped: jtreg.SkippedException: Skiping test for 25 cache size due max cache size 24

gc/g1/TestShrinkAuxiliaryData25.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values

Skipped: jtreg.SkippedException: Skiping test for 27 cache size due max cache size 24

gc/g1/TestShrinkAuxiliaryData27.java: Checks that decommitment occurs for JVM with different G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values

Skipped: jtreg.SkippedException: This system uses a crash report tool

serviceability/sa/ClhsdbCDSCore.java: Test the clhsdb commands 'printmdo', 'printall', 'jstack' on a CDS enabled corefile.
serviceability/sa/ClhsdbFindPC.java#id1: Test the clhsdb 'findpc' command with Xcomp on core file
serviceability/sa/ClhsdbFindPC.java#id3: Test the clhsdb 'findpc' command w/o Xcomp on core file
serviceability/sa/ClhsdbPmap.java#id1: Test clhsdb pmap command on a core file
serviceability/sa/ClhsdbPstack.java#id1: Test clhsdb pstack command on a core file
serviceability/sa/TestJmapCore.java: Test verifies that jhsdb jmap could generate heap dump from core when heap is full
serviceability/sa/TestJmapCoreMetaspace.java: Test verifies that jhsdb jmap could generate heap dump from core when metaspace is full

Skipped: jtreg.SkippedException: either NUMA or HugeTLB is not supported

gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java: Check large pages and NUMA are working together via the output message.

Report generated on Oct 23, 2025 8:35:14 PM
Using JT Harness 6.0 b22; built on January 3, 1970 at 12:00:00 AM UTC with openjdk version "11.0.17" 2022-10-18