// independent of the initial capacity, except that it won't be lower than the threshold
      // computed from that capacity. Because the internal table is only allocated on the first
      // write, we won't see copying because of the new threshold. So it is always OK to use the
      // calculation here.
      return (int) ceil(expectedSize / 0.75);
    }

      // independent of the initial capacity, except that it won't be lower than the threshold
      // computed from that capacity. Because the internal table is only allocated on the first
      // write, we won't see copying because of the new threshold. So it is always OK to use the
      // calculation here.
      return (int) ceil(expectedSize / 0.75);
    }

        // Test additional acquire
        session.acquire();
        assertTrue(session.isInUse(), "Session should still be in use after additional acquire");

        // Test release (still in use because of initial transport acquire)
        session.release();
        assertTrue(session.isInUse(), "Session should still be in use after one release");

        // Test final release
        session.release();

import okhttp3.OkHttpClient;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.Response;

/**
 * This prints events for a single in-flight call. It won't work for multiple concurrent calls
 * because we don't know what callStartNanos refers to.
 */
public final class PrintEventsNonConcurrent {
  private final OkHttpClient client = new OkHttpClient.Builder()
      .eventListener(new PrintingEventListener())
      .build();

 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :
 * someGraphAlgorithm(startNode, graph);
 * }
 *
 * This works because those types each implement {@code PredecessorsFunction}. It will also work
 * with any other implementation of this interface.
 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},

 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :
 * someGraphAlgorithm(startNode, graph);
 * }
 *
 * This works because those types each implement {@code SuccessorsFunction}. It will also work with
 * any other implementation of this interface.
 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},

    public Set<Feature<? super @Nullable Void>> getImpliedFeatures() {
      return emptySet();
    }
  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(

``` hl_lines="5"
.
├── app
│   ├── __init__.py
│   ├── main.py
│   └── test_main.py
```

Because this file is in the same package, you can use relative imports to import the object `app` from the `main` module (`main.py`):

{* ../../docs_src/app_testing/app_a_py39/test_main.py hl[3] *}

            fail("Expected CrawlerSystemException");
        } catch (final CrawlerSystemException e) {
            assertEquals("The inputstream is null.", e.getMessage());
            // Note: validateCalled will be false because exception is thrown
            // before the flag can be set, which is the expected behavior
            assertFalse("validateCalled should be false as exception thrown before flag set", extractor.isValidateCalled());
        }

    # o isSuppressBatchUpdate: (NotRequired - Default false)
    #  Does it suppress batch update at loading data?
    #  When you have a data error, you may get details for the error
    #  by this property changing. Because it is possible that
    #  the BatchUpdateException information is very short for debug.
    #
    #; isSuppressBatchUpdate = false
    # - - - - - - - - - -/