assertEquals("http://www.example.com/valid.html", sitemaps[sitemaps.length - 1].getLoc());
    }

    public void test_parseXmlSitemaps_emptyLocElement() {
        // URL entry with empty loc element should be skipped
        final String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                + "<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n" + "  <url>\n" + "    <loc></loc>\n"

	// the container or to a default string (e.g. "minio_master_key").
	//
	// We have to distinguish a explicit config from an implicit. Hence,
	// we unset the env. vars if they are set but empty or contain a path
	// which does not exist. The downside of this check is that if
	// MINIO_KMS_SECRET_KEY_FILE is set to a path that does not exist,
	// the server does not complain and start without a KMS config.
	//

   * implemented as "no-effort". No interrupts or other attempts are made to stop threads executing
   * tasks. Second, the returned list will always be empty, as any submitted task is considered to
   * have started execution. This applies also to tasks given to {@code invokeAll} or {@code
   * invokeAny} which are pending serial execution, even the subset of the tasks that have not yet

    /**
     * Return an array of Access Control Entry (ACE) objects representing
     * the security descriptor associated with this file or directory.
     * If no DACL is present, null is returned. If the DACL is empty, an array with 0 elements is returned.
     *
     * @param resolveSids
     *            Attempt to resolve the SIDs within each ACE form
     *            their numeric representation to their corresponding account names.

			accessKey:          credentials.AccessKey,
			secretKey:          credentials.SecretKey,
			expectedRespStatus: http.StatusBadRequest,
		},
		// Test case - 5.
		// setting the keys to be empty.
		// Expecting statusForbidden.
		{
			bucketName:         bucketName,
			bucketPolicyReader: nil,

			policyLen:          10,
			accessKey:          "",
			secretKey:          "",

	} else if strings.HasPrefix(s, "\n") || strings.Contains(s, "\n\n") {
		log.Printf("%s: contains a blank line", filename)
		exitCode = 1
	}
	if s == "" {
		log.Printf("%s: empty file", filename)
		exitCode = 1
	} else if s[len(s)-1] != '\n' {
		log.Printf("%s: missing final newline", filename)
		exitCode = 1
	}
	s = aliasReplacer.Replace(s)
	lines := strings.Split(s, "\n")

        // Remove second instance
        assertTrue(ruleManager.removeRule(rule));
        assertEquals(0, ruleManager.getRuleCount());
        assertFalse(ruleManager.hasRule(rule));
    }

    /**
     * Test empty RuleManager
     */
    public void test_emptyRuleManager() {
        assertEquals(0, ruleManager.getRuleCount());

        ResponseData responseData = new ResponseData();

            int result = request.encode(buffer, 100);

            assertTrue(result > 0);
            assertTrue(result <= buffer.length - 100);
        }

        @Test
        @DisplayName("Should handle empty data array")
        void testEmptyDataArray() {
            byte[] emptyData = new byte[0];
            byte[] name = "TEST_DATA".getBytes(StandardCharsets.UTF_8);

            parameters = null,
          )
        else ->
          AlgorithmIdentifier(
            algorithm = SHA256_WITH_ECDSA,
            parameters = ByteString.EMPTY,
          )
      }

    private fun generateKeyPair(): KeyPair =
      KeyPairGenerator.getInstance(keyAlgorithm).run {
        initialize(keySize, SecureRandom())
        generateKeyPair()
      }

    list.set(2, 2L);
    assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
  }

  public void testCopyOf_stream() {
    assertThat(ImmutableLongArray.copyOf(LongStream.empty()))
        .isSameInstanceAs(ImmutableLongArray.of());
    assertThat(ImmutableLongArray.copyOf(LongStream.of(0, 1, 3)).asList())
        .containsExactly(0L, 1L, 3L)
        .inOrder();
  }