@Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }

                operationRunner.run(runnableBuildOperation("<thread-1>") {
                    instant.action1Started
                    thread.blockUntil.action2Started
                })
            }
            thread.blockUntil.action1Started
            operationRunner.run(runnableBuildOperation("<thread-2>") {
                instant.action2Started
                thread.blockUntil.action1Finished
            })
        }

        "properties": {
          "policies": {

 * limitations under the License.
 */

package org.gradle.cache.internal;

import org.gradle.internal.operations.BuildOperationType;

import java.io.File;
import java.time.Instant;

public final class CacheCleanupBuildOperationType implements BuildOperationType<CacheCleanupBuildOperationType.Details, CacheCleanupBuildOperationType.Result> {

    /**
     * Sent when the cache is cleaned up.
     */

            "uid": "${DS_PROMETHEUS}"
          },
          "exemplar": true,
          "expr": "time() - max(minio_node_process_starttime_seconds{job=~\"$scrape_jobs\"})",
          "format": "time_series",
          "instant": true,
          "interval": "",
          "intervalFactor": 1,
          "legendFormat": "{{instance}}",
          "metric": "process_start_time_seconds",
          "refId": "A",
          "step": 60

    }

    def "listeners receive events concurrently"() {
        def listener1 = {
            thread.blockUntil.received
            instant.handled
        } as OperationCompletionListener
        def listener2 = {
            instant.received
            thread.blockUntil.handled
        } as OperationCompletionListener

        when:
        registry.onTaskCompletion(Providers.of(listener1))

// that the methods [Time.GobDecode], [Time.UnmarshalBinary], [Time.UnmarshalJSON] and
// [Time.UnmarshalText] are not concurrency-safe.
//
// Time instants can be compared using the [Time.Before], [Time.After], and [Time.Equal] methods.
// The [Time.Sub] method subtracts two instants, producing a [Duration].
// The [Time.Add] method adds a Time and a Duration, producing a Time.
//

    }

    private BuildOperationRecord loadOperation() {
        operations.firstMatchingRegex("Load (configuration cache|instant execution) state")
    }

    private BuildOperationRecord storeOperation() {
        operations.firstMatchingRegex("Store (configuration cache|instant execution) state.*")
    }

	if t == nil {
		return true
	}
	return t.Time.IsZero()
}

// Before reports whether the time instant t is before u.
func (t *MicroTime) Before(u *MicroTime) bool {
	if t != nil && u != nil {
		return t.Time.Before(u.Time)
	}
	return false
}

// Equal reports whether the time instant t is equal to u.
func (t *MicroTime) Equal(u *MicroTime) bool {
	if t == nil && u == nil {
		return true
	}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.curl.logging

import java.io.PrintWriter
import java.io.StringWriter
import java.time.Instant
import java.time.ZoneOffset
import java.time.format.DateTimeFormatterBuilder
import java.time.temporal.ChronoField.HOUR_OF_DAY
import java.time.temporal.ChronoField.MINUTE_OF_HOUR