"forbidden (403)" | forbidden
    }

    List<List<?>> retryCombinations() {
        def retries = []
        (1..3).each { ret ->
            // no retries on runtime errors, missing resources, authentication errors
            retries << [ret, runtimeError, 1]
            retries << [ret, missing, 1]
            retries << [ret, forbidden, 1]
            retries << [ret, unauthorized, 1]

                    }
                }
            }
        }

        then:
        instant.second > instant.first
    }

    def "runs action when not in forbidden state"() {
        def action = Mock(Supplier)
        def controller = controller(TestState.A)
        asWorker {
            controller.transition(TestState.A, TestState.B) {}
        }

        when:

            'LOGGER: executed task :project1:logLifecycle',
            'LOGGER: task :project1:log starting work',
            'LOGGER: task :project1:log completed work',
        )
        forbidden(
            // the custom logger should override this
            'BUILD SUCCESSFUL'
        )
    }

    private static createLogOutput() {
        new LogOutput() {{
            quiet(

				responsewriters.Forbidden(ctx, actingAsAttributes, w, req, fmt.Sprintf("unknown impersonation request type: %v", impersonationRequest), s)
				return
			}

			decision, reason, err := a.Authorize(ctx, actingAsAttributes)
			if err != nil || decision != authorizer.DecisionAllow {
				klog.V(4).InfoS("Forbidden", "URI", req.RequestURI, "reason", reason, "err", err)

     *
     * Implementation cannot use the Kotlin resolve inside, as this function is called during session initialization, so Analysis API access is forbidden.
     */
    public abstract fun provideExtensionsFor(module: KtModule): List<KaResolveExtension>

    public companion object {
        public val EP_NAME: ExtensionPointName<KaResolveExtensionProvider> =

				validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "conditions"), fmt.Sprintf("updates may not add a condition of type %q", t)))
			case !apiequality.Semantic.DeepEqual(oldConditions, newConditions):
				conditionDiff := cmp.Diff(oldConditions, newConditions)

            return "Called from a write action."
        }

        permissionRegistry.explicitAnalysisRestriction?.let { restriction ->
            return "Resolve is explicitly forbidden in the current action: ${restriction.description}."
        }

        error("Cannot get a rejection reason when analysis is allowed.")
    }

    private fun isProhibitedEdtAnalysis(application: Application): Boolean =

        assertThat(descriptions).containsExactlyInAnyOrder(
                "org.gradlebuild.WrongNullable.returnsNull() is using forbidden Nullable annotations: org.jetbrains.annotations.Nullable",
                "parameter 0 for org.gradlebuild.WrongNullable.acceptsNull(java.lang.String) is using forbidden Nullable annotations: org.jetbrains.annotations.Nullable"
        );
    }

    @Test

			hasExternalMetrics = true
		}
	}

	if minReplicas != nil && *minReplicas == 0 {
		if !hasObjectMetrics && !hasExternalMetrics {
			allErrs = append(allErrs, field.Forbidden(fldPath, "must specify at least one Object or External metric to support scaling to zero replicas"))
		}
	}

	return allErrs
}

                    } else {
                        events.add(new SimpleConditionEvent(method, true, method.getFullName() + " is not using forbidden Nullable"));
                    }
                }