Object toBeGCed = new Object();
    WeakReference<Object> ref = new WeakReference<>(toBeGCed);
    SettableFuture<@Nullable Void> settableFuture = SettableFuture.create();
    ListenableFuture<?> ignored =
        serializer.submitAsync(
            new AsyncCallable<@Nullable Void>() {
              @Override
              public ListenableFuture<@Nullable Void> call() {
                return settableFuture;

    assertThat("ß".map()).isEqualTo("ß")
    assertThat("ς".map()).isEqualTo("ς")
    assertThat("\u200c".map()).isEqualTo("\u200c")
    assertThat("\u200d".map()).isEqualTo("\u200d")
  }

  @Test fun ignored() {
    assertThat("\u200b".map()).isEqualTo("")
    assertThat("\ufeff".map()).isEqualTo("")
  }

  @Test fun disallowed() {
    assertThat("\u0080".mapExpectingErrors()).isEqualTo("\u0080")
  }

    @Keep
    public void foo(@Nullable HardToCreate ignored, String required) {
      checkNotNull(required);
    }
  }

  public void testCanCreateDefault() {
    shouldPass(new CanCreateDefault());
  }

  @SuppressWarnings("unused") // used by reflection
  private static class CannotCreateDefault {
    @Keep
    public void foo(HardToCreate ignored, String required) {
      checkNotNull(ignored);

    /**
     * Adds an error message to the error queue for later processing.
     * This method is thread-safe and can be called from multiple crawler threads.
     *
     * @param msg the error message to add; ignored if null or blank
     */
    public static void addError(final String msg) {
        if (StringUtil.isNotBlank(msg)) {
            errors.offer(msg);
        }
    }

    /**

    assertThat(verifier.verify("a.foo.com", session)).isFalse()
    assertThat(verifier.verify("bar.com", session)).isTrue()
    assertThat(verifier.verify("a.bar.com", session)).isFalse()
  }

  /**
   * Ignored due to incompatibilities between Android and Java on how non-ASCII subject alt names
   * are parsed. Android fails to parse these, which means we fall back to the CN. The RI does parse
   * them, so the CN is unused.
   */

            }
        };

        byte[] buf = new byte[128];
        // After header at 0..32
        buf[33] = 4; // wordCount
        buf[34] = (byte) 0xFF; // andxCommand
        // andxOffset (ignored when 0xFF)
        buf[36] = 0;
        buf[37] = 0;
        // byteCount at index start + 1 + wordCount*2 = 33 + 1 + 8 = 42
        ServerMessageBlock.writeInt2(20, buf, 42);

   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one
   * stream is longer, its extra elements will be ignored.
   *
   * <p>Note that if you are calling {@link Stream#forEach} on the resulting stream, you might want
   * to consider using {@link #forEachPair} instead of this method.
   *

        assertTrue(result instanceof BoolQueryBuilder);

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertTrue(boolResult.hasClauses());
        // FILTER should be ignored (default case in switch)
        assertEquals(1, boolResult.must().size());
    }

    // Test execute with MatchAllDocsQuery wrapped in BooleanQuery
    public void test_execute_withMatchAllDocsQuery() {

          continue;
        }
        responseQueue.put(new Response(request.methodName, result, null));
      }
    } catch (ThreadDeath death) {
      return;
    } catch (InterruptedException ignored) {
      // SynchronousQueue sometimes throws InterruptedException while the threads are stopping.
    } catch (Throwable uncaught) {
      this.uncaughtThrowable = uncaught;
    }
  }

            dynamicCircuitBreaker.updateFailureThreshold(7);
            assertEquals(7, dynamicCircuitBreaker.getCurrentFailureThreshold(), "Threshold should be updated");

            // Test that invalid threshold is ignored
            dynamicCircuitBreaker.updateFailureThreshold(-1);
            assertEquals(7, dynamicCircuitBreaker.getCurrentFailureThreshold(), "Threshold should not change for invalid value");

        } finally {