original1 instanceof Serializable

        def recreated1 = recreate(original1)
        def result1 = new StringBuilder()
        recreated1.execute(result1)

        result1.toString() == "123"

        def original2 = cl.thing(123)
        def result2 = recreate(original2).call()

        result2 == "123"
    }

    def "class can include only serializable lambda"() {
        given:

                    result = res;
                } else if (field.getType() == Node.class) {
                    result = res.getRoot();
                } else if (field.getType() == List.class && field.getGenericType() instanceof ParameterizedType pt) {
                    Type t = pt.getActualTypeArguments()[0];
                    if (t == Node.class) {
                        result = res.getNodes();

                }
                else -> {}
            }
        }
        return if (smartCastTypeToUse != null && result != null) {
            KaSmartCastedReceiverValue(result, smartCastTypeToUse.toKtType(analysisContext))
        } else {
            result
        }
    }

    private fun createSignature(symbol: KaSymbol, resultingDescriptor: CallableDescriptor): KaCallableSignature<*>? {

            withBuildScriptIn(".", randomScriptContent())

            val result = buildForCacheInspection("help", "--build-cache", "--info", "-Dorg.gradle.internal.kotlin-script-caching-disabled=$scriptCachingDisabled")

            if (scriptCachingDisabled) {
                result.assertNotOutput("Stored cache entry for Kotlin DSL script compilation")
                result.assertOutputContains("Caching of Kotlin script compilation disabled by property")

		return results[i].PetID > results[j].PetID
	})

	sort.Slice(results, func(i, j int) bool {
		return user.Pets[i].ID > user.Pets[j].ID
	})

	if len(results) != 2 || results[0].Name != user.Pets[0].Name || results[1].Name != user.Pets[1].Name {
		t.Errorf("Should find all two pets with Join select, got %+v", results)
	}
}

func TestJoinWithOmit(t *testing.T) {
	user := *GetUser("joins_with_omit", Config{Pets: 2})

//===----------------------------------------------------------------------===//

def LowerEmptyOp : Pat<(TF_EmptyOp:$result $dims, TrueBoolAttr:$init),
                      (TF_BroadcastToOp
                       (TF_ConstOp (GetScalarOfType<0> $result)), $dims),
                      [(TF_SintOrFpTensor $result)]>;

//===----------------------------------------------------------------------===//
// Inv op patterns.

        .matches(
            "[^\\[]+\\[status=PENDING, setFuture=\\[[^\\[]+\\[status=PENDING,"
                + " info=\\[cause=\\[Someday...]]]]]");
    testFuture2.set("result string");
    assertThat(testFuture3.toString())
        .matches("[^\\[]+\\[status=SUCCESS, result=\\[java.lang.String@\\w+\\]\\]");
  }

  public void testToString_cancelled() throws Exception {
    assertThat(Futures.immediateCancelledFuture().toString())

        def storeOp = operations.only(ConfigurationCacheStoreBuildOperationType)
        with(storeOp.result) {
            cacheEntrySize > 0
        }
        with(loadOp.result) {
            cacheEntrySize == storeOp.result.cacheEntrySize
        }
        def buildInvocationId = loadOp.result.originBuildInvocationId

        when:
        inDirectory 'lib'
        configurationCacheRun 'assemble'

                    TransformExecutionResult result = transform.transform(inputArtifactProvider, getOutputDir(workspace), dependencies, inputChanges);
                    TransformExecutionResultSerializer resultSerializer = new TransformExecutionResultSerializer();
                    resultSerializer.writeToFile(getResultsFile(workspace), result);
                    return result;
                } finally {

            TaskOperationResult result = BuildProgressListenerAdapter.toTaskResult(providerResult);
            DefaultTaskFinishEvent finishEvent = new DefaultTaskFinishEvent(providerEvent.getEventTime(), providerEvent.getDisplayName(), descriptor, result);
            listenerProvider.get().onFinish(finishEvent);
        }

        @Override