* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;


import java.net.UnknownHostException;


/**
 * This class represents a NetBIOS over TCP/IP address. Under normal
 * conditions, users of jCIFS need not be concerned with this class as
 * name resolution and session services are handled internally by the smb package.
 * 
 * <p>

            checkReferral(resp, req.getPath(), req);
        case NtStatus.NT_STATUS_BUFFER_OVERFLOW:
            break; /* normal for DCERPC named pipes */
        case NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED:
            break; /* normal for NTLMSSP */
        default:
            if ( log.isDebugEnabled() ) {

```Python hl_lines="2  12  15-18"
{!../../docs_src/app_testing/tutorial001.py!}
```

/// tip | "Tipp"

Beachten Sie, dass die Testfunktionen normal `def` und nicht `async def` sind.

Und die Anrufe an den Client sind ebenfalls normale Anrufe, die nicht `await` verwenden.

Dadurch können Sie `pytest` ohne Komplikationen direkt nutzen.

///

/// note | "Technische Details"

import okio.ByteString

/**
 * A non-blocking interface to a web socket. Use the [factory][WebSocket.Factory] to create
 * instances; usually this is [OkHttpClient].
 *
 * ## Web Socket Lifecycle
 *
 * Upon normal operation each web socket progresses through a sequence of states:
 *
 *  * **Connecting:** the initial state of each web socket. Messages may be enqueued but they won't
 *    be transmitted until the web socket is open.
 *

  // Maximal length of the note is 1kB, but libraries should be prepared to
  // handle values up to 64kB.
  // +optional
  optional string note = 10;

  // type is the type of this event (Normal, Warning), new types could be added in the future.
  // It is machine-readable.
  // This field cannot be empty for new Events.
  optional string type = 11;

                                                buffer, bufferIndex );
            } else {

                /*
                 * Just a plain smb. Read it as normal.
                 */

                buffer[bufferIndex++] = (byte)( andx.wordCount & 0xFF );

                if( andx.wordCount != 0 ) {
                    /*

For example, inside of an `async` *path operation function* you can get the contents with:

```Python
contents = await myfile.read()
```

If you are inside of a normal `def` *path operation function*, you can access the `UploadFile.file` directly, for example:

```Python
contents = myfile.file.read()
```

/// note | "`async` Technical Details"

   * Response and normal event sequences will not be received.
   *
   * This event will only be received when a Cache is configured for the client.
   */
  open fun cacheHit(
    call: Call,
    response: Response,
  ) {
  }

  /**
   * Invoked when a response will be served from the network. The Response will be
   * available from normal event sequences.
   *

            + " and-another-thing=\"\"; normal-thing=foo",
        MediaType.create("text", "plain")
            .withParameter("something", "cr@zy")
            .withParameter("something-else", "crazy with spaces")
            .withParameter("and-another-thing", "")
            .withParameter("normal-thing", "foo")
            .toString());
  }

      self.base(title, targets, desc)
      + options.legend.withCalcs([])
      + options.legend.withDisplayMode('list')
      + custom.withDrawStyle('bars')
      + custom.withStacking({ mode: 'normal' })
      + timeSeries.queryOptions.withInterval('15s')
      + timeSeries.standardOptions.withUnit('ops')
      + custom.withFillOpacity(100)
      + custom.withShowPoints('never')