public void testAddAllAtIndex_supportedNothing() {
    assertFalse("addAll(n, nothing) should return false", getList().addAll(0, emptyCollection()));
    expectUnchanged();
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(n, nothing) should return false or throw",
          getList().addAll(0, emptyCollection()));

  public void testGet_yes() {
    assertEquals("get(present) should return the associated value", v0(), get(k0()));
  }

  public void testGet_no() {
    assertNull("get(notPresent) should return null", get(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedButAllowed() {
    assertNull("get(null) should return null", get(null));
  }

        try {
            emptyEnv.get("non.existent.property");
            fail("Should throw ConfigPropertyNotFoundException");
        } catch (ConfigPropertyNotFoundException e) {
            assertTrue(e.getMessage().contains("non.existent.property"));
        }

        try {
            emptyEnv.is("non.existent.boolean");
            fail("Should throw ConfigPropertyNotFoundException");

        }

        assertTrue("GET method should exist", hasGet);
        assertTrue("POST method should exist", hasPost);
        assertTrue("PUT method should exist", hasPut);
        assertTrue("DELETE method should exist", hasDelete);
        assertTrue("HEAD method should exist", hasHead);
        assertTrue("OPTIONS method should exist", hasOptions);
        assertTrue("TRACE method should exist", hasTrace);

        String value1 = fessConfig.get(testKey);
        String value2 = fessConfig.get(testKey);

        // Values should be the same
        assertEquals("Test Fess", value1);
        assertEquals(value1, value2);
    }

    // Test property that should be consistent
    public void test_get_propertyFilter() {
        // Test a regular property that passes through

        .Builder()
        .body("abc")
        .addHeader("Content-Type: text/plain")
        .build(),
    )

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)

# /---------------------------------------------------------------------------
# databaseInfoMap: (Required)
#
# The database information for the tasks of DBFlute.
# You should specify before your first generating.
#
# o driver   -- The class name of JDBC-Driver.
# o url      -- The URL for connecting database.
# o schema   -- The schema name.
# o user     -- The database user name.
# o password -- The database password.

        thread.join(1000);

        String output = thread.getOutput();
        assertTrue("Should contain recent lines", output.contains("line5"));

        assertTrue("Should have line3", thread.contains("line3"));
        assertTrue("Should have line4", thread.contains("line4"));
        assertTrue("Should have line5", thread.contains("line5"));
    }

   * Helper to assert common expected behaviour of uri escapers. You should call
   * assertBasicUrlEscaper() unless the escaper explicitly does not escape '%'.
   */
  static void assertBasicUrlEscaperExceptPercent(UnicodeEscaper e) {
    // URL escapers should throw null pointer exceptions for null input
    try {
      e.escape((String) null);
      fail("Escaping null string should throw exception");
    } catch (NullPointerException x) {

            TestFessLabels labels = new TestFessLabels();
            labels.testAssertPropertyNotNull(null);
            fail("Should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertEquals("The argument 'property' for message should not be null.", e.getMessage());
        }
    }

    /**
     * Test that assertPropertyNotNull does not throw exception for non-null input