import org.gradle.internal.UncheckedException;
import org.gradle.internal.scan.UsedByScanPlugin;

import javax.annotation.Nullable;

/**
 * A {@code PlaceholderException} is used when an exception cannot be serialized or deserialized.
 */
@UsedByScanPlugin
public class PlaceholderException extends RuntimeException implements PlaceholderExceptionSupport {
    private final String exceptionClassName;
    private final Throwable getMessageException;

            at ClassName.testName(MyTest.java:22)
"""
    }

    def "formats PlaceholderException correctly"() {
        testLogging.getShowCauses() >> true
        testLogging.getShowStackTraces() >> true
        testLogging.getStackTraceFilters() >> EnumSet.of(TestStackTraceFilter.ENTRY_POINT)

        def cause = new PlaceholderException(RuntimeException.name, "oops", null, "java.lang.RuntimeException: oops", null, null)

class PlaceholderExceptionTest extends Specification {
    def "toString() generally produces same output as original exception"() {
        def original = new Exception("original exception")
        def placeholder = new PlaceholderException(original.getClass().name, original.message, null, original.toString(), null, original.cause)

        expect:
        placeholder.toString() == original.toString()
    }

 */

package org.gradle.internal.serialize;

import org.gradle.internal.exceptions.Contextual;

import javax.annotation.Nullable;

@Contextual
public class ContextualPlaceholderException extends PlaceholderException {
    public ContextualPlaceholderException(String exceptionClassName, @Nullable String message, @Nullable Throwable getMessageException, @Nullable String toString, @Nullable Throwable toStringException, @Nullable Throwable cause) {

     * reason) will be replaced by a {@link PlaceholderException}.
     *
     * @param inputSteam stream to read the object from
     * @param classLoader loader used to load exception classes
     * @return the de-serialized object
     */

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import org.gradle.internal.UncheckedException;

import javax.annotation.Nullable;

/**
 * A {@code PlaceholderException} is used when an assertion error cannot be serialized or deserialized.
 */
public class PlaceholderAssertionError extends AssertionError implements PlaceholderExceptionSupport {
    private final String exceptionClassName;

import org.gradle.internal.logging.events.UserInputResumeEvent
import org.gradle.internal.logging.events.YesNoQuestionPromptEvent
import org.gradle.internal.serialize.DefaultSerializer
import org.gradle.internal.serialize.PlaceholderException
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.serialize.SerializerSpec
import org.gradle.launcher.daemon.diagnostics.DaemonDiagnostics
import org.gradle.launcher.exec.BuildActionResult

            def Object o = new Object()
        }

        when:
        def transported = transport(broken)

        then:
        transported.class == PlaceholderException
        transported.cause == null
        transported.stackTrace.length == 0

        when:
        transported.message

        then:
        RuntimeException e = thrown()

                } else {
                    placeholder = new PlaceholderException(type, message, getMessageExec, toString, toStringRuntimeExec, causes.isEmpty() ? null : causes.get(0));
                }
            }
        } else {

Class <org.gradle.internal.serialize.PlaceholderException> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (PlaceholderException.java:0)