}

  @Test fun `cannot decode malformed utc time`() {
    val bytes = "170d3139313231362333303231305a".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.UTC_TIME.fromDer(bytes)
    }.also { expected ->
      assertThat(expected).hasMessage("Failed to parse UTCTime 191216#30210Z")
    }
  }

  @Test fun `cannot decode generalized time with offset`() {

import (
	"errors"

	"github.com/minio/minio/internal/s3select/jstream"
	"github.com/minio/simdjson-go"
)

var (
	errKeyLookup                  = errors.New("Cannot look up key in non-object value")
	errIndexLookup                = errors.New("Cannot look up array index in non-array value")
	errWildcardObjectLookup       = errors.New("Object wildcard used on non-object value")

    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonnegative(long value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

            @Nonnull Session session, @Nonnull ArtifactCoordinates coordinates) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))
                .groupId(requireNonNull(coordinates, "coordinates cannot be null")
                        .getGroupId())
                .artifactId(coordinates.getArtifactId())
                .version(coordinates.getVersionConstraint().toString())

        this.mavenProject = Objects.requireNonNull(mavenProject, "mavenProject cannot be null");
        this.pomFile = pomFile;
        context = JXPathContext.newContext(mavenProject.getModel());
    }

    public PomTestWrapper(MavenProject mavenProject) {
        this.mavenProject = Objects.requireNonNull(mavenProject, "mavenProject cannot be null");
        context = JXPathContext.newContext(mavenProject.getModel());
    }

        this.syncContextFactory = Objects.requireNonNull(syncContextFactory, "syncContextFactory cannot be null");
        this.repositoryEventDispatcher =
                Objects.requireNonNull(repositoryEventDispatcher, "repositoryEventDispatcher cannot be null");
        this.versionScheme = Objects.requireNonNull(versionScheme, "versionScheme cannot be null");
    }

    @Override

    @Override
    public WorkspaceRepository getRepository() {
        return this.repository;
    }

    @Override
    public Model findModel(Artifact artifact) {
        requireNonNull(artifact, "artifact cannot be null");
        Model model = null;

        for (WorkspaceReader workspaceReader : readers) {
            if (workspaceReader instanceof MavenWorkspaceReader mavenWorkspaceReader) {

## Concepts

- If an object is under legal hold, it cannot be deleted unless the legal hold is explicitly removed for the respective version id. DeleteObjectVersion() would fail otherwise.

        }

        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, List<Artifact> pluginArtifacts) {
        Objects.requireNonNull(pluginArtifacts, "pluginArtifacts cannot be null");

        assertUniqueKey(key);

        CacheRecord record = new CacheRecord(Collections.unmodifiableList(new ArrayList<>(pluginArtifacts)));

        cache.put(key, record);

	for _, e := range includes {
		if len(e) == 0 {
			return nil, config.ErrInvalidCompressionIncludesValue(nil).Msg("extension/mime-type cannot be empty")
		}
		if e == "/" {
			return nil, config.ErrInvalidCompressionIncludesValue(nil).Msg("extension/mime-type cannot be '/'")
		}
	}
	return includes, nil
}

// LookupConfig - lookup compression config.
func LookupConfig(kvs config.KVS) (Config, error) {