return time.Since(cache.lastUpdate) > 5*time.Minute
	}
	return true
}

// keepAlive will continuously update lastHandout until ctx is canceled.
func (m metacache) keepAlive(ctx context.Context, rpc *peerRESTClient) {
	// we intentionally operate on a copy of m, so we can update without locks.
	t := time.NewTicker(metacacheMaxClientWait / 10)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():

// Exclude patterns (must not match)
crawler.urlFilter.addExclude(".*\\.(css|js|png|jpg)$");
```

### Setting Crawl Limits

```java
context.setMaxAccessCount(1000);  // Max URLs (0 = unlimited)
context.setMaxDepth(3);           // Max depth (-1 = unlimited)
context.setNumOfThread(10);       // Concurrent threads
```

### Accessing Results

```java
DataService ds = container.getComponent("dataService");

	}

	var contents []ItemContent
	if err := tx.Find(&contents).Error; err != nil {
		t.Errorf("failed to find contents, got error: %v", err)
	}
	if len(contents) != 3 {
		t.Errorf("expected %d contents, got %d", 3, len(contents))
	}

	// test delete
	if err := tx.Model(&item).Association("Contents").Unscoped().Delete(&contents[0]); err != nil {
		t.Errorf("failed to delete Contents, got error: %v", err)
	}

      description: Tell us what should happen
    validations:
      required: true
  - type: textarea
    id: context
    attributes:
      label: Context (optional)
      description: |
        How has this issue affected you? What are you trying to accomplish?
        Providing context helps us come up with a solution that is most useful in the real world
    validations:
      required: false
  - type: textarea

    }

    /**
     * Get lifetime of this context.
     *
     * @return the remaining lifetime in seconds. If the default lifetime is
     *         used, this value have no meaning.
     */
    public int getLifeTime() {
        return this.contextLifetime;
    }

    /**
     * Set the lifetime for this context.
     *
     * @param time
     *            the lifetime in seconds

     * @return session instance with the given type
     */
    <T extends SmbSession> T unwrap(Class<T> type);

    /**
     * Returns the CIFS context that this session is attached to.
     *
     * @return the context this session is attached to
     */
    CIFSContext getContext();

     */
    @Deprecated
    Model interpolate(Model project, Map<String, ?> context) throws ModelInterpolationException;

    /**
     * @deprecated Use {@link ModelInterpolator#interpolate(Model, File, ProjectBuilderConfiguration, boolean)} instead.
     */
    @Deprecated
    Model interpolate(Model model, Map<String, ?> context, boolean strict) throws ModelInterpolationException;

class OkHttpClientTestRuleTest {
  lateinit var extensionContext: ExtensionContext

  @RegisterExtension @JvmField
  val beforeEachCallback =
    BeforeEachCallback { context ->
      ******@****.***ionContext = context
    }

  @Test fun uncaughtException() {
    val testRule = OkHttpClientTestRule()
    testRule.beforeEach(extensionContext)

    val thread =
      object : Thread() {

 *
 * @param <C> The context type.
 */
public interface CoreExtensionSelector<C extends LookupContext> {
    /**
     * Selects core extensions to be loaded from list of all sources detected.
     */
    @Nonnull
    List<CoreExtension> selectCoreExtensions(LookupInvoker<C> invoker, C context);

 *
 * @author mbechler
 *
 * <p>This interface is intended for internal use.</p>
 */
public interface SmbTransport extends AutoCloseable {

    /**
     * Gets the CIFS context associated with this transport.
     *
     * @return the context this transport is attached to
     */
    CIFSContext getContext();

    /**
     * Unwraps the transport to the specified type.
     *
     * @param <T> the type to unwrap to