return err
	}
	evnot.targetList = evnot.targetList.Init(runtime.GOMAXPROCS(0)) // TODO: make this configurable (y4m4)
	return nil
}

// AddRulesMap - adds rules map for bucket name.
func (evnot *EventNotifier) AddRulesMap(bucketName string, rulesMap event.RulesMap) {
	evnot.Lock()
	defer evnot.Unlock()

	rulesMap = rulesMap.Clone()

	// Do not add for an empty rulesMap.

                            artifactRules =
                                if (index == 0) {
                                    // The artifact rule report/css/*.css => performanceResultsDir is there to clean up the target directory.
                                    // If we don't clean that up there might be leftover json files from other report builds running on the same machine.

 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.
 *

import org.codelibs.fess.crawler.service.UrlFilterService;

import jakarta.annotation.Resource;

/**
 * Implementation of the {@link UrlFilterService} interface.
 * This class provides methods for managing URL filtering rules,
 * including adding include and exclude URL patterns, deleting patterns,
 * and retrieving lists of compiled URL patterns. It utilizes a
 * {@link MemoryDataHelper} to store and manage the URL patterns in memory.
 *
 */

        assertTrue(result.contains("exclude1"));
    }

    public void test_getCacheKey_sorting() {
        String seed = "test_seed";
        String[] tags = { "zzz", "aaa", "mmm" };
        String[] roles = { "role3", "role1", "role2" };
        String[] fields = { "field3", "field1", "field2" };
        String[] excludes = { "exclude3", "exclude1", "exclude2" };

// This input was created by taking the instruction productions in
// the old assembler's (8a's) grammar and hand-writing complete
// instructions for each rule, to guarantee we cover the same space.

#include "../../../../../runtime/textflag.h"

TEXT foo(SB), DUPOK|NOSPLIT, $0

// LTYPE1 nonrem	{ outcode(int($1), &$2); }
	SETCC	AX
	SETCC	foo+4(SB)

// LTYPE2 rimnon	{ outcode(int($1), &$2); }
	DIVB	AX
	DIVB	foo+4(SB)
	PUSHL	$foo+4(SB)

```sh
awscli s3api put-object-lock-configuration --bucket mybucket --object-lock-configuration 'ObjectLockEnabled=\"Enabled\",Rule={DefaultRetention={Mode=\"GOVERNANCE\",Days=1}}'
```

### Set object lock

// license that can be found in the LICENSE file.

// This input was created by taking the instruction productions in
// the old assembler's (6a's) grammar and hand-writing complete
// instructions for each rule, to guarantee we cover the same space.

#include "../../../../../runtime/textflag.h"

TEXT	foo(SB), DUPOK|NOSPLIT, $0

// LTYPE1 nonrem	{ outcode($1, &$2); }
	NEGQ	R11
	NEGQ	4(R11)
	NEGQ	foo+4(SB)

      for (futureTask in futureTasks) {
        if (futureTask is AwaitIdleTask) {
          return futureTask.latch
        }
      }

      // Don't delegate to schedule() because that enforces shutdown rules.
      val newTask = AwaitIdleTask()
      if (scheduleAndDecide(newTask, 0L, recurrence = false)) {
        taskRunner.kickCoordinator(this)
      }
      return newTask.latch
    }
  }

 *
 * <p>The parser handles the following GSA configuration elements:
 * <ul>
 * <li>Collections with good/bad URL patterns</li>
 * <li>Global parameters including start URLs and filtering rules</li>
 * <li>User agent settings</li>
 * <li>URL pattern matching with regular expressions and contains filters</li>
 * </ul>
 *
 */
public class GsaConfigParser extends DefaultHandler {