private static final Pattern ID_REGEX = Pattern.compile(ID);

    private static final String ILLEGAL_REPO_ID_CHARS = "\\/:\"<>|?*"; // ILLEGAL_FS_CHARS

    @Override
    public void validate(Settings settings, SettingsProblemCollector problems) {
        if (settings.isUsePluginRegistry()) {
            addViolation(problems, Severity.WARNING, "usePluginRegistry", null, "is deprecated and has no effect.");

   */
  public void register(Object object) {
    subscribers.register(object);
  }

  /**
   * Unregisters all subscriber methods on a registered {@code object}.
   *
   * @param object object whose subscriber methods should be unregistered.
   * @throws IllegalArgumentException if the object was not previously registered.
   */
  public void unregister(Object object) {

Not all client code is compiled with NullAway.
Do not make a parameter `@Nullable` just to check and throw a `NullPointerException` when it is `null`. 

## Consequences

* Classes are forced to have consistent nullability annotations.
* IDE warnings become more accurate, reducing warnings fatigue.
* Public API nullability annotations become closer to reality.

   * very flexible regarding wildcard rules, but this flexibility is not something currently used
   * in practice. To simplify the implementation, we've avoided implementing the flexible rules in
   * favor of supporting what's actually used in practice. That means if these assertions ever fail,
   * the implementation will need to be revisited to support a more flexible rule.
   */

     */
    public void setConvertUrlMap(final Map<String, String> convertUrlMap) {
        this.convertUrlMap.putAll(convertUrlMap);
    }

    /**
     * Adds a URL conversion rule.
     *
     * @param regex the regular expression pattern to match
     * @param replacement the replacement string
     */
    public void addConvertUrl(final String regex, final String replacement) {

     */
    public ChatSessionManager() {
        // Default constructor
    }

    /**
     * Initializes the session manager and starts the cleanup scheduler.
     */
    @PostConstruct
    public void init() {
        // 5 minutes = 300 seconds
        cleanupTask = TimeoutManager.getInstance().addTimeoutTarget(this::cleanupExpiredSessions, 300, true);
        if (logger.isDebugEnabled()) {

  EXPECT_EQ(22, product[3]);
  TF_DeleteStatus(status);
}
TEST(CAPI, Executor_MatMul_CPU) { Executor_MatMul_CPU(false); }
TEST(CAPI, Executor_MatMul_CPUAsync) { Executor_MatMul_CPU(true); }

void Deleter(void* data, size_t unused, void* tensor_handle) {
  TFE_DeleteTensorHandle(static_cast<TFE_TensorHandle*>(tensor_handle));
}

TEST(CAPI, TensorHandleOnDeviceMemory) {
  TF_Status* status = TF_NewStatus();

 *
 * @author Chris Nokleberg
 */

@SuppressWarnings("deprecation") // tests of a deprecated method
@NullUnmarked
public class FilesCreateTempDirTest extends TestCase {
  public void testCreateTempDir() throws IOException {
    File temp = Files.createTempDir();
    try {
      assertThat(temp.exists()).isTrue();
      assertThat(temp.isDirectory()).isTrue();
      assertThat(temp.listFiles()).isEmpty();

        return valid;
    }

    /**
     * Invalidate this memory region
     *
     * After invalidation, the region cannot be used for RDMA operations.
     */
    public abstract void invalidate();

    /**
     * Generate local key for this memory region
     *
     * @return local key
     */
    protected abstract int generateLocalKey();

    /**

        this.transformerManager = transformerManager;
    }

    public void buildProject(
            MavenSession session, ReactorContext reactorContext, MavenProject currentProject, TaskSegment taskSegment) {
        buildProject(session, session, reactorContext, currentProject, taskSegment);
    }

    public void buildProject(
            MavenSession session,
            MavenSession rootSession,