const char* description) {
  auto* result = new TFE_MonitoringCounter0({name, description});
  tsl::Set_TF_Status_from_Status(status, result->counter->GetStatus());
  if (!result->counter->GetStatus().ok()) {
    delete result;
    return nullptr;
  }
  return result;
}

void TFE_MonitoringDeleteCounter0(TFE_MonitoringCounter0* counter) {
  delete counter;
}

	if err != nil {
		return fmt.Errorf("failed to get container status %q: %v", containerID, err)
	}
	if resp.GetStatus() == nil {
		return fmt.Errorf("container status is nil for %q", containerID)
	}
	pattern := fmt.Sprintf("%s*", resp.GetStatus().GetLogPath())
	logs, err := c.osInterface.Glob(pattern)
	if err != nil {

        } else {
            // Mark the state as 'ad hoc' and not cacheable
            return localResolveStateFactory.adHocStateFor(model, componentIdentifier, moduleVersionIdentifier, configurationsProvider, module.getStatus(), schema);
        }
    }

    private boolean shouldCacheResolutionState() {

        }

        @Override
        public void run() {
            try {
                final DaemonExpirationResult result = expirationStrategy.checkExpiration();
                if (result.getStatus() != DO_NOT_EXPIRE) {
                    listenerBroadcast.onExpirationEvent(result);
                }
            } catch (Throwable t) {

        if (state instanceof OperationGroup) {
            OperationGroup group = (OperationGroup) state;
            group.setStatus(completeEvent.getStatus(), completeEvent.isFailed());
            group.flushOutput();
            if (group.hasForeground()) {
                lastRenderedBuildOpId = null;
            }
        }
    }

                IvyModuleResolveMetadata ivyMetadata = (IvyModuleResolveMetadata) legacyMetadata;
                return new DefaultIvyModuleDescriptor(ivyMetadata.getExtraAttributes(), ivyMetadata.getBranch(), ivyMetadata.getStatus());
            }
        }
        return null;
    }

    private boolean resolve() {
        if (cachedResult == null) {
            cachedResult = resolveState.resolve();
        }

        componentMetadata.statusScheme == ['foo', 'bar']
    }

    def "can use a component metadata processor to tweak user provided metadata"() {
        def processedMetadata = Mock(ComponentMetadata) {
            getStatus() >> 'from rule'
            getStatusScheme() >> ['from', 'rule']
        }
        given:
        resolveState.id >> id

    override fun getBuildscript(): ScriptHandler =
        delegate.buildscript

    override fun getStatus(): Any =
        delegate.status

    override fun mkdir(path: Any): File =
        delegate.mkdir(path)

    override fun setStatus(status: Any) {
        delegate.status = status
    }

    override fun getConfigurations(): ConfigurationContainer =

    def resolvedWithStatus(String status, Map<String, ?> attributes) {
        def meta = Stub(ModuleComponentResolveMetadata) {
            getStatusScheme() >> ["integration", "milestone", "release"]
            getStatus() >> status
            getAttributes() >> AttributeTestUtil.attributes(attributes)
        }
        def state = Stub(ModuleComponentGraphResolveState) {
            getLegacyMetadata() >> meta
        }

        LocalComponentGraphResolveMetadata copiedMetadata = new LocalComponentGraphResolveMetadata(
            originalMetadata.getModuleVersionId(),
            newComponentId,
            originalMetadata.getStatus(),
            originalMetadata.getAttributesSchema()
        );

        return new DefaultLocalComponentGraphResolveState(
            idGenerator.nextComponentId(),
            copiedMetadata,