}
              }
              return true;
            };
    TypeWithDuplicates a = new TypeWithDuplicates(1, 1);
    TypeWithDuplicates b1 = new TypeWithDuplicates(2, 1);
    TypeWithDuplicates b2 = new TypeWithDuplicates(2, 2);
    TypeWithDuplicates c = new TypeWithDuplicates(3, 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(

                try {
                    return new java.util.Date(Long.parseLong(s));
                } catch (NumberFormatException e) {
                    throw new XmlPullParserException(e.getMessage(), parser, e);
                }
            } else {
                try {
                    DateFormat dateParser = new java.text.SimpleDateFormat(effectiveDateFormat, java.util.Locale.US);

    protected DocumentBuilderFactoryUtil() {
    }

    /**
     * Returns a new instance of {@link DocumentBuilderFactory}.
     *
     * @return A new instance of {@link DocumentBuilderFactory}.
     */
    public static DocumentBuilderFactory newInstance() {
        return newInstance(false);
    }

    /**
     * Returns a new instance of {@link DocumentBuilderFactory}.
     *
     * @param external

            List<MetadataRequest> metadataReqs =
                    new ArrayList<>(request.getRepositories().size());

            metadataReqs.add(new MetadataRequest(metadata, null, request.getRequestContext()));

            for (RemoteRepository repository : request.getRepositories()) {
                MetadataRequest metadataRequest =
                        new MetadataRequest(metadata, repository, request.getRequestContext());

            scratchArc = new FST.Arc<>();
        }

        ch = 0;
        readBuffer = new char[BUFFER_SIZE];
        readBufferIndex = BUFFER_SIZE;
        readBufferLen = 0;
        block = new StringBuilder();
        nextBlkStart = 0;
        queue = new PriorityQueue<>(100, new MyTokensComparator());
        this.synonyms = new ArrayList<>();
    }

    @Override

  private static Test testsForHashMapNullKeysForbidden() {
    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override
          Map<String, String> wrap(HashMap<String, String> map) {
            if (map.containsKey(null)) {
              throw new NullPointerException();
            }
            return new AbstractMap<String, String>() {
              @Override

        long t;

        return switch (enc) {
        case TIME_1970_SEC_32BE -> new Date(dec_uint32be(src, si) * 1000L);
        case TIME_1970_SEC_32LE -> new Date(dec_uint32le(src, si) * 1000L);
        case TIME_1904_SEC_32BE -> new Date(((dec_uint32be(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);
        case TIME_1904_SEC_32LE -> new Date(((dec_uint32le(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);

        context.setNotificationFilter(0x1F);

        // Test encoding and decoding roundtrip
        byte[] buffer = new byte[context.size()];
        int encoded = context.encode(buffer, 0);
        assertEquals(context.size(), encoded);

        DirectoryLeaseContext decodedContext = new DirectoryLeaseContext(new Smb2LeaseKey(), 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);

        decodedContext.decode(buffer, 0, buffer.length);

	v := strings.SplitN(s, ":", 2)
	if len(v) != 2 {
		return nil, errors.New("kms: invalid secret key format")
	}

	keyID, b64Key := v[0], v[1]
	key, err := base64.StdEncoding.DecodeString(b64Key)
	if err != nil {
		return nil, err
	}
	return NewBuiltin(keyID, key)
}

// NewBuiltin returns a single-key KMS that derives new DEKs from the
// given key.
func NewBuiltin(keyID string, key []byte) (*KMS, error) {

    }

    private static Metadata createMetadata(Artifact artifact) {
        Snapshot snapshot = new Snapshot();
        snapshot.setLocalCopy(true);
        Versioning versioning = new Versioning();
        versioning.setSnapshot(snapshot);

        Metadata metadata = new Metadata();
        metadata.setVersioning(versioning);
        metadata.setGroupId(artifact.getGroupId());