// the file from concurrent access across mount points.
// This implementation doesn't support all the open
// flags and shouldn't be considered as replacement
// for os.OpenFile().
func LockedOpenFile(path string, flag int, perm os.FileMode) (*LockedFile, error) {
	return lockedOpenFile(path, flag, perm, syscall.F_SETLKW)
}

// Open - Call os.OpenFile
func Open(path string, flag int, perm os.FileMode) (*os.File, error) {

//
// It dials one by one and returns first connected `net.Conn`.
// If it fails to dial all IPs from cache it returns first error. If no baseDialFunc
// is given, it sets default dial function.
//
// You can use returned dial function for `http.Transport.DialContext`.
//
// In this function, it uses functions from `rand` package. To make it really random,
// you MUST call `rand.Seed` and change the value from the default in your application

        localhostIpv4,
        localhostIpv6,
      )
    serverIpv4.enqueue(
      MockResponse(body = "unexpected call to IPv4"),
    )
    serverIpv6.enqueue(
      MockResponse(body = "hello from IPv6"),
    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

Auf diese Weise können Sie die Dinge für den Client-Code richtig ordnen und gruppieren:

<img src="/img/tutorial/generate-clients/image06.png">

In diesem Fall haben Sie:

* `ItemsService`
* `UsersService`

### Client-Methodennamen { #client-method-names }

Im Moment sehen die generierten Methodennamen wie `createItemItemsPost` nicht sehr sauber aus:

      this.replaceLength = replacements.length;
    }

    /*
     * Overriding escape method to be slightly faster for this decorator. We test the replacements
     * array directly, saving a method call.
     */
    @Override
    public String escape(String s) {
      int slen = s.length();
      for (int index = 0; index < slen; index++) {
        char c = s.charAt(index);

     * specified through this <code>jcifs.properties</code> system property.
     *
     * @return a global context, initialized on first call
     */
    public static synchronized final SingletonContext getInstance() {
        if (INSTANCE == null) {
            try {
                log.debug("Initializing singleton context");
                init(null);

        assertEquals(NtStatus.NT_STATUS_UNSUCCESSFUL, ex.getNtStatus(), "Status should default to unsuccessful for message+cause ctor");
    }

    // Interaction: passing a mocked cause should not trigger interactions (nothing to call)
    @Test
    @DisplayName("Mocked cause: no interactions occur when stored as cause")
    void mockedCause_isStored_withoutInteraction() {
        // Arrange
        Throwable mocked = mock(Throwable.class);

Standardmäßig überprüft die Methode `.openapi()` die Eigenschaft `.openapi_schema`, um zu sehen, ob diese Inhalt hat, und gibt diesen zurück.

Ist das nicht der Fall, wird der Inhalt mithilfe der Hilfsfunktion unter `fastapi.openapi.utils.get_openapi` generiert.

Diese Funktion `get_openapi()` erhält als Parameter:

* `title`: Der OpenAPI-Titel, der in der Dokumentation angezeigt wird.

	db := DB.Scopes(func(tx *gorm.DB) *gorm.DB {
		return tx.Table("custom_table")
	}).Session(&gorm.Session{})

	db.AutoMigrate(&User{})
	if db.Find(&User{}).Statement.Table != "custom_table" {
		t.Errorf("failed to call Scopes")
	}

	result := DB.Scopes(NameIn1And2, func(tx *gorm.DB) *gorm.DB {
		return tx.Session(&gorm.Session{})
	}).Find(&users1)

	if result.RowsAffected != 2 {

        new ServiceManager(Arrays.<Service>asList(new FailRunService(), new FailStartService()));
    // Due to the implementation of the two services we know that both are now failed.  So the
    // following awaitHealthy call is just to get the exception.
    manager.startAsync();
    assertThat(manager.servicesByState().get(State.FAILED)).hasSize(2);
    IllegalStateException e = assertThrows(IllegalStateException.class, manager::awaitHealthy);