start {
                result4 = cache.get("key", producer, Stub(Runnable))
            }
        }

        then:
        result1 == "result"
        result2 == "result"
        result3 == "result"
        result4 == "result"

        and:
        1 * target.get("key") >> null
        1 * producer.apply("key") >> "result"
        1 * target.putLater("key", "result", _)
        0 * producer._

*/

package probe

// Result is a string used to handle the results for probing container readiness/liveness
type Result string

const (
	// Success Result
	Success Result = "success"
	// Warning Result. Logically success, but with additional debugging information attached.
	Warning Result = "warning"
	// Failure Result
	Failure Result = "failure"
	// Unknown Result
	Unknown Result = "unknown"

            result.missing()
        }
        1 * localAccess2.resolveComponentMetaData(moduleComponentId, componentRequestMetaData, _) >> { id, meta, result ->
            result.missing()
            result.authoritative = false
        }
        1 * remoteAccess2.resolveComponentMetaData(moduleComponentId, componentRequestMetaData, _) >> { id, meta, result ->
            result.resolved(componentState)

		t.Errorf("Failed to commit transaction, got error %v\n", err)
	}

	if result := db.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 1 {
		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	tx2 := db.Begin()
	if result := tx2.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 0 {

    ++task_iter;
  }
  auto results = coord_agent->GetTaskState(task_vec);
  if (!results.ok()) {
    status->status = results.status();
    return;
  }
  auto* state_iter = static_cast<TF_Status*>(states);
  for (size_t i = 0; i < tasks.length; ++i) {
    const auto& result = (*results)[i];
    TF_Status s;
    TF_SetStatus(&s, static_cast<TF_Code>(result.error_code()),

        result.failure == null
        result.hasResult()
    }

    def "can have missing result"() {
        when:
        result.notFound(artifactId)

        then:
        result.failure instanceof ArtifactNotFoundException
        result.hasResult()

        when:
        result.result

        then:
        def e = thrown(ArtifactNotFoundException)
        result.failure == e
    }

    def "can change the destination for test results and reports with #dsl dsl"() {
        given:
        TestFile dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        def result = fails("test")

        then: "the test task is executed"
        result.assertTaskExecuted(":test")

        and: "the test results are in the custom directory"

        when:
        def result = serialize(identifier, serializer)

        then:
        result.identityPath == identifier.identityPath
        result.projectPath == identifier.projectPath
        result.buildTreePath == identifier.buildTreePath
        result.projectPath() == identifier.projectPath()
        result.projectName == identifier.projectName
    }

    def "serializes root build ProjectComponentIdentifier"() {

            result = concat(result, CATEGORY_ATTRIBUTE, new CoercingStringValueSnapshot(Category.DOCUMENTATION, objectInstantiator));
            result = concat(result, Bundling.BUNDLING_ATTRIBUTE, objectInstantiator.named(Bundling.class, Bundling.EXTERNAL));
            result = concat(result, DocsType.DOCS_TYPE_ATTRIBUTE, objectInstantiator.named(DocsType.class, DocsType.JAVADOC));

        succeeds("help")

        then:
        def result = result()

        result.enabled
        result.localEnabled
        !result.remoteEnabled

        result.local.className == 'org.gradle.caching.local.DirectoryBuildCache'
        result.local.config.location == cacheDir.absoluteFile.toString()
        result.local.config.removeUnusedEntriesAfter == "7 days"
        result.local.type == 'directory'
        result.local.push == true