*/
    public abstract fun renderAsKotlinConstant(): String

    public class KaNullConstantValue(override val sourcePsi: KtElement?) : KaConstantValue(ConstantValueKind.Null) {
        override val value: Nothing? get() = null
        override fun renderAsKotlinConstant(): String = "null"
    }

    public class KaBooleanConstantValue(
        override val value: Boolean,
        override val sourcePsi: KtElement?

        if (!dir.exists()) {
            // Directory does not exist, nothing to clean up
            return Optional.empty();
        }

        if (!gcFile.exists()) {
            // If GC file hasn't been created, then this cache hasn't been used before.
            // We create the GC file, but there's nothing to clean up
            try {
                FileUtils.touch(gcFile);

    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/enum_partial.kt");
  }

  @Test
  @TestMetadata("nothing.kt")
  public void testNothing() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/nothing.kt");
  }

  @Test
  @TestMetadata("nullableBoolean.kt")
  public void testNullableBoolean() {

    public static final int CREATE = 1;

    public static final int EDIT = 2;

    public static final int DELETE = 3;

    public static final int DETAILS = 4;

    protected CrudMode() {
        // nothing
    }

                if (candidateValues.contains(javaRuntimeJars)) {
                    // Use the Jars when nothing has been requested
                    details.closestMatch(javaRuntimeJars);
                } else if (candidateValues.contains(javaRuntime)) {
                    // Use the runtime when nothing has been requested
                    details.closestMatch(javaRuntime);
                }
            } else {

    static int instanceCount = 0;

    public TestComponentMetadataRule() {
        instanceCount++;
    }

    @Override
    public void execute(ComponentMetadataContext componentMetadataContext) {
        // Do nothing for now
    }

// *containing* linked_ptr<> must have a constructor and destructor (even
// if they do nothing!).
//
// Bill Gibbons suggested we use something like this.
//
// Thread Safety:
//   Unlike other linked_ptr implementations, in this implementation
//   a linked_ptr object is thread-safe in the sense that:
//     - it's safe to copy linked_ptr objects concurrently,

// license that can be found in the LICENSE file.

package abi

import "unsafe"

// NoEscape hides the pointer p from escape analysis, preventing it
// from escaping to the heap. It compiles down to nothing.
//
// WARNING: This is very subtle to use correctly. The caller must
// ensure that it's truly safe for p to not escape to the heap by
// maintaining runtime pointer invariants (for example, that globals

		preFilterWantStatus *framework.Status
		wantStatus          *framework.Status
	}{
		{
			pod:                 &v1.Pod{},
			nodeInfo:            framework.NewNodeInfo(),
			name:                "nothing",
			preFilterWantStatus: framework.NewStatus(framework.Skip),
			wantStatus:          nil,
		},
		{
			pod:                 &v1.Pod{},
			nodeInfo:            framework.NewNodeInfo(st.MakePod().Volume(volState).Obj()),

                      VALUE_PARAMETER name:it index:0 type:kotlin.Int
                      BLOCK_BODY
                        RETURN type=kotlin.Nothing from='local final fun <anonymous> (it: kotlin.Int): kotlin.Boolean declared in <root>.CodeFragment.run'