// Initialize the filter
        crawler.urlFilter.init(crawler.getSessionId());

        // Add a URL that matches the filter
        crawler.addUrl("http://example.com/page");

        assertTrue(crawler.urlFilter.match("http://example.com/page"));
    }

    public void test_addExcludeFilter() throws Exception {
        crawler.addIncludeFilter("http://example\\.com/.*");

@GwtIncompatible
@J2ktIncompatible
@J2ObjCIncompatible // com.google.common.reflect.ClassPath
@NullMarked
public abstract class AbstractPackageSanityTests extends TestCase {

  /**
   * A predicate that matches classes with an underscore in the class name. This can be used with
   * {@link #ignoreClasses} to exclude generated classes, such as the {@code AutoValue_Foo} classes

				// is available and honored at this domain.
				//
				// All other `<bucket>.<namespace>.svc.<cluster_domain>`
				// makes sure that buckets are routed through this matcher
				// to match for `<bucket>`
				return host != minioReservedBucket+"."+domainName
			}).Host("{bucket:.+}."+domainName).Subrouter())
		} else {
			routers = append(routers, apiRouter.Host("{bucket:.+}."+domainName).Subrouter())

		time.Unix(0, x.ModTime),
		x.Flags.String(),
		x.EcN, x.EcM,
	)
}

// matchesNotStrict returns whether x and o have both have non-zero version,
// their versions match and their type match.
// If they have zero version, modtime must match.
func (x xlMetaV2VersionHeader) matchesNotStrict(o xlMetaV2VersionHeader) (ok bool) {
	ok = x.VersionID == o.VersionID && x.Type == o.Type && x.matchesEC(o)
	if x.VersionID == [16]byte{} {

   * methods that do not take an explicit timeout value, a single test case is generated only if the
   * implicit timeout of that method matches the given timeoutsToUse. For example, enter() is
   * treated like enter(MAX, MILLIS) and tryEnter() is treated like enter(0, MILLIS).
   */
  private static void addTests(
      TestSuite suite,
      Method method,

			Usage: "export inline data",
			Name:  "export",
		},
		cli.BoolFlag{
			Usage: "combine inline data",
			Name:  "combine",
		},
		cli.BoolFlag{
			Usage: "combine inline data across versions when size matches",
			Name:  "xver",
		},
	}

	app.Action = func(c *cli.Context) error {
		ndjson := c.Bool("ndjson")
		if c.Bool("data") && c.Bool("combine") {
			return errors.New("cannot combine --data and --combine")

				"ctime":                         "1386065770.449252304",
				"SCHILY.xattr.security.selinux": "unconfined_u:object_r:default_t:s0\x00",
			},
			Format: FormatPAX,
		}},
	}, {
		// Matches the behavior of GNU, BSD, and STAR tar utilities.
		file: "testdata/gnu-multi-hdrs.tar",
		headers: []*Header{{
			Name:     "GNU2/GNU2/long-path-name",
			Linkname: "GNU4/GNU4/long-linkpath-name",

        if (share == null) {
            share = "IPC$";
        }

        synchronized (this.trees) {
            for (SmbTreeImpl t : this.trees) {
                if (t.matches(share, service)) {
                    return t.acquire();
                }
            }
            SmbTreeImpl t = new SmbTreeImpl(this, share, service);
            t.acquire();
            this.trees.add(t);

            if (ssn.matches(tf, targetHost, targetDomain)) {
                if (log.isTraceEnabled()) {
                    log.trace("Reusing existing session " + ssn);
                }
                return ssn.acquire();
            }
            if (log.isTraceEnabled()) {
                log.trace("Existing session " + ssn + " does not match " + tf.getCredentials());
            }
        }

		if err != nil {
			t.Fatalf("Test %d: %s: Failed parsing response body: <ERROR> %v", i+1, instanceType, err)
		}

		if recV4.Code != testCase.expectedRespStatus {
			// Verify whether the bucket policy fetched is same as the one inserted.
			var expectedPolicy *policy.BucketPolicy
			expectedPolicy, err = policy.ParseBucketPolicyConfig(strings.NewReader(expectedBucketPolicyStr), testCase.bucketName)
			if err != nil {