package tar_test

import (
	"archive/tar"
	"bytes"
	"fmt"
	"io"
	"log"
	"os"
)

func Example_minimal() {
	// Create and add some files to the archive.
	var buf bytes.Buffer
	tw := tar.NewWriter(&buf)
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},

 */
package jcifs.internal.smb2.rdma;

/**
 * RDMA credit management for flow control.
 *
 * Credits are used to control the flow of messages between
 * RDMA peers to prevent buffer overflow.
 */
public class RdmaCredits {

    private int initialCredits;
    private int creditsGranted;

    /**
     * Create new RDMA credits manager
     */
    public RdmaCredits() {

     * @return a new message builder
     */
    @Nonnull
    MessageBuilder builder();

    /**
     * Creates a new message builder of the specified size.
     * @param size the initial size of the message builder buffer
     * @return a new message builder
     */
    @Nonnull
    MessageBuilder builder(int size);

    }

    @Test
    @DisplayName("getBufferCache should return initialized buffer cache")
    void testGetBufferCache() {
        // When
        BufferCache bufferCache = context.getBufferCache();

        // Then
        assertNotNull(bufferCache, "Buffer cache should not be null");
        assertSame(bufferCache, context.getBufferCache(), "Should return same instance on multiple calls");

import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.Interceptor
import okhttp3.Response
import okhttp3.internal.USER_AGENT
import okhttp3.internal.toHostHeader
import okio.GzipSource
import okio.buffer

/**
 * Bridges from application code to network code. First it builds a network request from a user
 * request. Then it proceeds to call the network. Finally it builds a user response from the network
 * response.
 */

        this.fileId = fileId;
    }

    /**
     * Constructs an SMB2 IOCTL request with output buffer
     * @param config the client configuration
     * @param controlCode the IOCTL control code
     * @param fileId the file identifier
     * @param outputBuffer the output buffer for the IOCTL operation
     */

/// note | Hinweis

Wenn Sie bereits wissen, was HTTP-Statuscodes sind, überspringen Sie dieses Kapitel und fahren Sie mit dem nächsten fort.

///

In HTTP senden Sie als Teil der Response einen aus drei Ziffern bestehenden numerischen Statuscode.

Diese Statuscodes haben einen Namen zugeordnet, um sie besser zu erkennen, aber der wichtige Teil ist die Zahl.

Kurz:

        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

	initialized bool
	group       *singleflight.Group
	metadataMap map[string]BucketMetadata
}

// Count returns number of bucket metadata map entries.
func (sys *BucketMetadataSys) Count() int {
	sys.RLock()
	defer sys.RUnlock()

	return len(sys.metadataMap)
}

// Remove bucket metadata from memory.
func (sys *BucketMetadataSys) Remove(buckets ...string) {
	sys.Lock()
	for _, bucket := range buckets {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.io

import java.io.IOException
import okio.Buffer
import okio.FileSystem
import okio.ForwardingFileSystem
import okio.ForwardingSink
import okio.Path
import okio.Sink

class FaultyFileSystem constructor(
  delegate: FileSystem?,