JT Harness : Tests that passed

java/rmi/MarshalledObject/MOFilterTest.java: Test MarshalledObject applies ObjectInputFilter
java/rmi/MarshalledObject/compare/Compare.java: Codebase annotations on classes that are marshalled should not affect the behavior of MarshalledObject.equals.
java/rmi/MarshalledObject/compare/HashCode.java: MarshalledObject with null throws NullPointerException
java/rmi/MarshalledObject/compare/NullReference.java: MarshalledObject with null throws NullPointerException.
java/rmi/Naming/DefaultRegistryPort.java: change in default URL port causes regression in java.rmi.Naming
java/rmi/Naming/LookupIPv6.java: Ensure that java.rmi.Naming.lookup can handle URLs containing IPv6 addresses.
java/rmi/Naming/LookupNameWithColon.java: Ensure that java.rmi.Naming.lookup functions properly for names containing embedded ':' characters.
java/rmi/Naming/RmiIsNoScheme.java: Protocol "rmi:" is used in contrary to spec.
java/rmi/Naming/UnderscoreHost.java: Ensure that Naming.java correctly parses host names with '_' in them.
java/rmi/Naming/legalRegistryNames/LegalRegistryNames.java: Naming assumes '/' is present in relative URL; change in URL causes regression
java/rmi/RMISecurityManager/checkPackageAccess/CheckPackageAccess.java: When an instance of java.rmi.RMISecurityManager is set the VM's security manager, the same package access restrictions should be in effect as when the default java.lang.SecurityManager is set, which with the default "java.security" file in the JDK means that access to packages in the sun.* package hierarchy is denied (without explicit runtime permission "accessClassInPackage.*").
java/rmi/RemoteException/chaining/Chaining.java: test chained exception support
java/rmi/dgc/VMID/CheckVMID.java: VMIDs should be unique regardless of whether an IP address can be obtained.
java/rmi/dgc/dgcImplInsulation/DGCImplInsulation.java: The RMI runtime's server-side DGC implementation object should not be exported with the arbitrary access control context that was in effect when it gets lazily created.
java/rmi/invalidName/InvalidName.java: (1.x) java.rmi.Naming defaults to local hostname, not local IP address
java/rmi/module/ModuleTest.java: Basic tests for using rmi in module world
java/rmi/registry/altSecurityManager/AltSecurityManager.java: rmiregistry could allow alternate security manager
java/rmi/registry/classPathCodebase/ClassPathCodebase.java: When a class that can be found in the CLASSPATH of the rmiregistry tool is marshalled via RMI, it should be annotated with the value of the java.rmi.server.codebase property, not the list of "file:" URLs for the actual elements of the CLASSPATH.
java/rmi/registry/emptyName/EmptyName.java: check that registry allows empty names
java/rmi/registry/interfaceHash/InterfaceHash.java: Stubs and skeletons used to implement the RMI registry implementation and the bootstrap stubs must always follow certain "well known" protocols so that they otherwise need not be in sync-- in other words, a registry stub from any arbitrary J2SE vendor and version must be able to communicate with a registry skeleton from any other arbitrary J2SE vendor and version.
java/rmi/registry/nonLocalRegistry/NonLocalSkeletonTest.java#id0: Verify that Registry rejects non-local access for bind, unbind, rebind.
java/rmi/registry/readTest/CodebaseTest.java: remove java.rmi.server.codebase property parsing from registyimpl
java/rmi/registry/reexport/Reexport.java: RMI registry creation is impossible if first attempt fails.
java/rmi/registry/serialFilter/RegistryFilterTest.java: Test filters for the RMI Registry
java/rmi/reliability/benchmark/bench/rmi/Main.java: The RMI benchmark test.
java/rmi/reliability/benchmark/bench/serial/Main.java: The Serialization benchmark test.
java/rmi/reliability/juicer/AppleUserImpl.java: The juicer is the classic RMI stress test.
java/rmi/server/ObjID/randomIDs/RandomIDs.java: When the "java.rmi.server.randomIDs" system property is not defined, the ObjID() constructor should behave as if it were set to "true" and generate random object numbers; if the property is defined to something other than "true" (ignoring case), then ObjID() should still generate sequential object numbers.
java/rmi/server/RMIClassLoader/delegateBeforePermissionCheck/DelegateBeforePermissionCheck.java: When the RMIClassLoader.loadClass() methods are invoked with a codebase URL that the caller does not have permission to load from, but with a class name that is accessible through the caller's context class loader (such as in the boot or system class paths, for an application), the operations should succeed, instead of throwing a ClassNotFoundException (wrapping a SecurityExcpetion) because the caller does not have permission to access the codebase URL.
java/rmi/server/RMIClassLoader/delegateToContextLoader/DelegateToContextLoader.java: RMIClassLoader's loadClass() method that takes explicit URLs should load classes from a class loader that delegates to the current thread's context class loader (not just the base class loader always).
java/rmi/server/RMIClassLoader/downloadArrayClass/DownloadArrayClass.java: If the type of a parameter or return value in an RMI call can be successfully downloaded by the receiving endpoint, then an array class with that type as its element type should likewise be able to be successfully downloaded.
java/rmi/server/RMIClassLoader/getClassAnnotation/NullClass.java: RMIClassLoader.getClassAnnotation() needs to specify behavior for null class
java/rmi/server/RMIClassLoader/getClassLoader/GetClassLoader.java: RMIClassLoader.getClassLoader for a codebase should return the same class loader that is used to load classes from that codebase (using RMIClassLoader.loadClass).
java/rmi/server/RMIClassLoader/loadProxyClasses/LoadProxyClasses.java: functional test for RMIClassLoader.loadProxyClass; test ensures that the default RMI class loader provider implements RMIClassLoader.loadProxyClass correctly.
java/rmi/server/RMIClassLoader/noSecurityManager/NoSecurityManager.java: RMIClassLoader's loadClass() methods, when there is no security manager installed, should not create or use RMI class loader instances for the requested codebases, but they should still succeed to load classes that can be found by delegation to parent class loader that would have been used for the RMI class loader instance.
java/rmi/server/RMIClassLoader/spi/ContextInsulation.java: verify that the java.util.ServiceLoader-based location of an RMIClassLoader provider does not require any permissions of the (arbitrary) protection domains that happens to be on the stack when RMIClassLoader is first used.
java/rmi/server/RMIClassLoader/spi/DefaultProperty.java: verify that setting the java.rmi.server.RMIClassLoaderSpi system property to "default" causes the default provider instance to be used by the RMIClassLoader API.
java/rmi/server/RMIClassLoader/spi/Installed.java: verify that with the java.rmi.server.RMIClassLoaderSpi system property not set, the first provider located through java.util.ServiceLoader (which should be "TestProvider2") will be used by the RMIClassLoader API.
java/rmi/server/RMIClassLoader/spi/InvalidProperty.java: verify that an inavlid setting of the system property java.rmi.server.RMIClassLoaderSpi causes an Error to be thrown to users of the RMIClassLoader API.
java/rmi/server/RMIClassLoader/spi/Property.java: verify that the value of the java.rmi.server.RMIClassLoaderSpi system property is interpreted to name the class to instantiate for the RMIClassLoader provider.
java/rmi/server/RMIClassLoader/useCodebaseOnly/UseCodebaseOnly.java: If the "java.rmi.server.useCodebaseOnly" property has a boolean value of true, then when the RMI runtime is unmarshalling a class descriptor, it should not attempt to download the associate Class object from the annotated codebase, but only from the codebase specified in the "java.rmi.server.codebase" property and the context class loader.
java/rmi/server/RMIClassLoader/useCodebaseOnlyDefault/UseCodebaseOnlyDefault.java: Tests proper parsing and defaulting of the "java.rmi.server.useCodebaseOnly" property.
java/rmi/server/RMIClassLoader/useGetURLs/UseGetURLs.java: When the RMIClassLoader.getClassAnnotation() is called with a class loaded from any URLClassLoader instance (not just those created for internal use by the RMI runtime), then it should return a String containing a space-separated list of the class loader's path of URLs.
java/rmi/server/RMISocketFactory/useSocketFactory/registry/UseCustomSocketFactory.java: synopsis: need to obtain remote references securely
java/rmi/server/RMISocketFactory/useSocketFactory/unicast/UseCustomSocketFactory.java: synopsis: need to download factories for use with custom socket types
java/rmi/server/RemoteObject/notExtending/NotExtending.java: Remote classes not extending RemoteObject should be able to implement hashCode() and equals() methods so that instances can be successfully compared to RemoteObject instances (specifically: stubs) that contain the instance's RemoteRef.
java/rmi/server/RemoteObject/toStub/ToStub.java: support using dynamic proxies as RMI stubs
java/rmi/server/RemoteObject/unrecognizedRefType/UnrecognizedRefType.java: This test verifies that when a RemoteObject is being deserialized, if the "external ref type name" is a non-empty string that is not equal to one of the external ref type names required to be supported by the specification, then a ClassNotFoundException is thrown.
java/rmi/server/RemoteObject/verifyRemoteEquals/VerifyRemoteEquals.java: equals does not works on stub objects created with custom socket AndFactory
java/rmi/server/RemoteServer/SetLogNull.java: The method java.rmi.server.RemoteServer.setLog should never throw a NullPointerException when its argument is null even if it has never been invoked before, or even if its last invocation also had an argument of null.
java/rmi/server/RemoteServer/setLogPermission/SetLogPermission.java: SecurityException can be obtained but is not specified.
java/rmi/server/UnicastRemoteObject/changeHostName/ChangeHostName.java: RMI needs a mechanism to dynamically change a VMs RMI serverHostname.
java/rmi/server/UnicastRemoteObject/exportObject/GcDuringExport.java: GC'ing objects whilst being exported to RMI should not cause exceptions
java/rmi/server/UnicastRemoteObject/keepAliveDuringCall/KeepAliveDuringCall.java: In addition to keeping the VM alive (with a non-daeman thread) while there are remote objects exported, the RMI runtime should also keep it alive while there remain calls in progress (to remote objects the have presumably been unexported), so that a remote object can more conveniently implement a graceful remote shutdown method (that unexports the object).
java/rmi/server/UnicastRemoteObject/marshalAfterUnexport/MarshalAfterUnexport.java: After an instance of UnicastRemoteObject has been unexported, if it gets marshalled, an InternalError should not be thrown; instead, the marshalling should succeed.
java/rmi/server/UnicastRemoteObject/marshalAfterUnexport/MarshalAfterUnexport2.java: After an instance of UnicastRemoteObject has been unexported, if it gets marshalled, an InternalError should not be thrown; instead, the marshalling should succeed.
java/rmi/server/UnicastRemoteObject/useDynamicProxies/UseDynamicProxies.java: support using dynamic proxies as RMI stubs
java/rmi/server/Unmarshal/PrimitiveClasses.java: Verify that RMI can successfully unmarshal Class objects for primitive types.
java/rmi/server/Unmarshal/checkUnmarshalOnStopThread/CheckUnmarshalOnStopThread.java: RuntimeExceptions can corrupt call connections that may be reused.
java/rmi/server/Unreferenced/leaseCheckInterval/LeaseCheckInterval.java: When the "java.rmi.dgc.leaseValue" system property is set to a value much lower than its default (10 minutes), then the server-side user-visible detection of DGC lease expiration-- in the form of Unreferenced.unreferenced() invocations and possibly even local garbage collection (including weak reference notification, finalization, etc.)-- may be delayed longer than expected.
java/rmi/server/Unreferenced/marshalledObjectGet/MarshalledObjectGet.java: When an object is retrieved from a MarshalledObject, callbacks that were registered by objects in the graph for execution when the unmarshalling is done should get executed.
java/rmi/server/Unreferenced/unreferencedContext/UnreferencedContext.java: Unreferenced.unreferenced(...) threads should run in the nonSystem group.
java/rmi/server/clientStackTrace/ClientStackTrace.java: RemoteException should have server's stack trace
java/rmi/server/getRemoteClass/GetRemoteClass.java: trivial optimization in RemoteProxy.extendsRemote
java/rmi/server/serverStackTrace/ServerStackTrace.java: When an exception is thrown by a remote method invocation, the stack trace of the exception catchable by the client application should comprise both the client-side trace as well as the server-side trace, as serialized with the Throwable from the server.
java/rmi/server/serverStackTrace/SuppressStackTraces.java: When the system property "sun.rmi.server.suppressStackTraces" is set to boolean true, then the RMI runtime should take positive action to counteract the new feature in 1.4 of an exception's stack trace being part of its serialized form so that the server-side stack trace of an exception that occurs during the execution of a remote method invocation gets marshalled to the client.
java/rmi/server/useCustomRef/UseCustomRef.java: remote references can't be downloaded
java/rmi/testlibrary/TestSocketFactory.java: TestSocket Factory and tests of the basic trigger, match, and replace functions
java/rmi/transport/acceptLoop/CloseServerSocketOnTermination.java: When the current RMIFailureHandler (if any) is invoked because of a server socket accept failure, if it returns false, then (in addition to the accept loop terminating) the associated server socket should be closed.
java/rmi/transport/checkFQDN/CheckFQDN.java: Endpoint hostnames should always be fully qualified or should be an ip address.
java/rmi/transport/closeServerSocket/CloseServerSocket.java: After all of the remote objects (including a registry, if applicable) that had been exported with a given RMIServerSocketFactory value (including null) have been unexported, the server socket created for the exports should be closed (so that the local port is released).
java/rmi/transport/dgcDeadLock/DGCDeadLock.java: synopsis: Distributed Garbage Collection Deadlock
java/rmi/transport/handshakeFailure/HandshakeFailure.java: Whan an RMI (JRMP) connection is made to a TCP address that is listening, so the connection is accepted, but the server responds with invalid JRMP protocol (such as because a non-JRMP server is currently listening at that address), the client application should receive a java.rmi.ConnectException or ConnectIOException, not a MarshalException.
java/rmi/transport/handshakeTimeout/HandshakeTimeout.java: When an RMI (JRMP) connection is made to a TCP address that is listening, so the connection is accepted, but the server never responds to the initial JRMP handshake (nor does it terminate the connection), the client should not hang forever; instead, it should throw an exception after a reasonable timeout interval.
java/rmi/transport/pinClientSocketFactory/PinClientSocketFactory.java: When a remote stub contains a client socket factory and a remote invocation is made using that stub, the factory should not be held strongly reachable by the RMI implementation forever; in particular, after the stub has become unreachable and all connections to its endpoint have been closed, then the factory should become unreachable too (through the RMI implementation).
java/rmi/transport/pinLastArguments/PinLastArguments.java: Passing live remote references as part of the arguments of a remote invocation should not cause an AssertionError (on the second and subsequent attempts) when system assertions are enabled, nor should it cause the references to be pinned until a subsequent such remote invocation occurs (if the argument stream was not released cleanly because of a marshalling failure).
java/rmi/transport/rapidExportUnexport/RapidExportUnexport.java: Rapidly alternating the number of remote objects exported on an explicit port between zero and greater than zero (thus causing the associated server socket to be created and closed repeatedly) should not encounter substantial synchronous delays because of the server socket accept loop's failure throttling procedure (which sleeps 10 seconds after 10 rapid failures).
java/rmi/transport/readTimeout/ReadTimeoutTest.java: Incoming connections should be subject to timeout
java/rmi/transport/reuseDefaultPort/ReuseDefaultPort.java: After a remote object has been exported on an anonymous port, it should be possible to export another remote object on an explicit port (and with the same socket factories, if any) with the same value as the actual port to which the first export got bound.
java/rmi/transport/runtimeThreadInheritanceLeak/RuntimeThreadInheritanceLeak.java: When the RMI runtime (lazily) spawns system threads that could outlive the application context in which they were (happened to be) created, such threads should not inherit (thread local) data specific to such an application context for various isolation reasons (see 4219095).
sun/rmi/log/ReliableLog/LogAlignmentTest.java: rmid can have a corrupted log
sun/rmi/log/ReliableLog/SnapshotSize.java: Verify that ReliableLog.snapshotSize() returns correct snapshot file size even if LogHandler doesn't flush.
sun/rmi/runtime/Log/4504153/Test4504153.java: RMI implementation should not log to two loggers where one is an ancestor of the other, to avoid unintended or duplicate logging
sun/rmi/runtime/Log/6409194/NoConsoleOutput.java: There should be no console output caused by the RMI implementation's logging, except as explicitly configured in the logging properties file, if none of the legacy sun.rmi.*.logLevel system properties are set.
sun/rmi/runtime/Log/checkLogging/CheckLogStreams.java: RMI should use new logging APIs.
sun/rmi/runtime/Log/checkLogging/CheckLogging.java: RMI should use new logging APIs.
sun/rmi/server/MarshalOutputStream/marshalForeignStub/MarshalForeignStub.java: When marshalling an object that implements java.rmi.Remote, but is not a RemoteStub and its corresponding stub class is not known by the RMI runtime, RMI's MarshalOutputStream should assume that the object is a proxy of some sort (like an RMI/IIOP stub) and simply allow the object to be serialized.
sun/rmi/transport/tcp/DeadCachedConnection.java: unable to retry call if cached connection to server is used
sun/rmi/transport/tcp/disableMultiplexing/DisableMultiplexing.java: The RMI runtime should fail to export a remote object on a TCP port for an applet or application that does not have permission to listen on that port, rather than engage in the deprecated "multiplexing protocol".

Report generated on Nov 16, 2024 3:15:34 AM
Using JT Harness 6.0 b24; built on December 7, 2023 at 12:00:00 AM AEDT with openjdk version "11.0.21" 2023-10-17