if (targetNode.equals(entry.getValue())) {
            return entry.getKey();
          }
        }
        return endOfData();
      }
    };
  }

  @Override
  public boolean contains(@Nullable Object edge) {
    return targetNode.equals(outEdgeToNode.get(edge));
  }

  <name>Guava ListenableFuture only</name>
  <description>
    An empty artifact that Guava depends on to signal that it is providing
    ListenableFuture -- but is also available in a second "version" that
    contains com.google.common.util.concurrent.ListenableFuture class, without
    any other Guava classes. The idea is:

    - If users want only ListenableFuture, they depend on listenablefuture-1.0.

You can override these exception handlers with your own.

### Override request validation exceptions { #override-request-validation-exceptions }

When a request contains invalid data, **FastAPI** internally raises a `RequestValidationError`.

And it also includes a default exception handler for it.

        // When
        CIFSException exception = new CIFSException(cause);

        // Then
        assertNotNull(exception);
        assertEquals(cause, exception.getCause());
        assertTrue(exception.getMessage().contains("Root cause"));
    }

    @Test
    @DisplayName("Should handle null message")
    void testNullMessage() {
        // When/Then
        assertDoesNotThrow(() -> {

        assertTrue(npe1.getMessage().contains("non-null"));

        NullPointerException npe2 = assertThrows(NullPointerException.class, () -> filter.accept(mockDir, null));
        assertTrue(npe2.getMessage().contains("non-null"));
        verifyNoInteractions(mockDir);
    }

    /**

        // Verify string contains all important fields
        assertTrue(result.contains("SmbFindFileBothDirectoryInfo"));
        assertTrue(result.contains("nextEntryOffset=100"));
        assertTrue(result.contains("fileIndex=200"));
        assertTrue(result.contains("creationTime="));
        assertTrue(result.contains("lastAccessTime="));
        assertTrue(result.contains("lastWriteTime="));

        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

    protected open fun shouldInclude(taskPath: String): Boolean = parameters.monitoredTaskPaths.get().contains(taskPath)

    abstract fun action(taskPath: String, taskResult: TaskOperationResult)

    }
  }

  /**
   * Returns {@code true} if this queue contains the specified element. More formally, returns
   * {@code true} if and only if this queue contains at least one element {@code e} such that {@code
   * o.equals(e)}.
   *
   * @param o object to be checked for containment in this queue
   * @return {@code true} if this queue contains the specified element
   */
  @CanIgnoreReturnValue
  @Override

For example, in `app/main.py` you could have a line like:

```
from app.routers import items
```

///

* The `app` directory contains everything. And it has an empty file `app/__init__.py`, so it is a "Python package" (a collection of "Python modules"): `app`.
* It contains an `app/main.py` file. As it is inside a Python package (a directory with a file `__init__.py`), it is a "module" of that package: `app.main`.

// dataUsageCacheV2 contains a cache of data usage entries version 2.
type dataUsageCacheV2 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV2
}

// dataUsageCacheV3 contains a cache of data usage entries version 3.
type dataUsageCacheV3 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV3
}

// dataUsageCacheV4 contains a cache of data usage entries version 4.