assertFalse(context.isEstablished());
        assertNull(context.getServerChallenge());
        assertNull(context.getSigningKey());
        assertNull(context.getNetbiosName());

        int expectedFlags = NtlmFlags.NTLMSSP_REQUEST_TARGET | NtlmFlags.NTLMSSP_NEGOTIATE_NTLM2 | NtlmFlags.NTLMSSP_NEGOTIATE_128

kubernetesVersion: v1.9.1
noTaintMaster: true
```

And point to the file using the --config flag, as in

`kubeadm init --config /etc/kubeadm/kubeadm.yaml`

([#55479](https://github.com/kubernetes/kubernetes/pull/55479), [@ijc](https://github.com/ijc))

                .thenReturn(handle); // second attempt succeeds

        // dest currently has READONLY attribute set
        int currentAttrs = SmbConstants.ATTR_READONLY | SmbConstants.ATTR_ARCHIVE;
        when(dest.getAttributes()).thenReturn(currentAttrs);

        int desiredAttrs = SmbConstants.ATTR_NORMAL;

        // Act
        SmbFileHandleImpl result = SmbCopyUtil.openCopyTargetFile(dest, desiredAttrs, false);

Вы бы сделали то же самое, чтобы объявить `tuple` и `set`:

{* ../../docs_src/python_types/tutorial007.py hl[1,4] *}


Это означает:

* Переменная `items_t` является `tuple` с 3 элементами: `int`, другим `int` и `str`.
* Переменная `items_s` является `set` и каждый элемент имеет тип `bytes`.

#### `Dict`

Чтобы определить `dict`, вы передаёте 2 параметра типов, разделённых запятыми.

	xhttp "github.com/minio/minio/internal/http"
)

func TestGetObjectLambdaHandler(t *testing.T) {
	testCases := []struct {
		name         string
		statusCode   int
		body         string
		contentType  string
		expectStatus int
	}{
		{
			name:         "Success 206 Partial Content",
			statusCode:   206,
			body:         "partial-object-data",
			contentType:  "text/plain",
			expectStatus: 206,
		},

    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];
      Object expectedValue = alternatingKeysAndValues[2 * i + 1];

    public Iterator<Entry<K, V>> iterator() {
      return entryIterator();
    }
  }

  @WeakOuter
  final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return Sets.equalsImpl(this, obj);
    }
  }

    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {
        baos.write(value & 0xFF);
        baos.write((value >> 8) & 0xFF);
        baos.write((value >> 16) & 0xFF);
        baos.write((value >> 24) & 0xFF);
    }

    private void writeLittleEndianLong(ByteArrayOutputStream baos, long value) {
        for (int i = 0; i < 8; i++) {
            baos.write((int) ((value >> (i * 8)) & 0xFF));
        }
    }

    UNIFORM_0_TO_2(0, 2),
    UNIFORM_0_TO_9(0, 9),
    ALWAYS_0(0, 0),
    ALWAYS_10(10, 10);

    final int min;
    final int max;

    ListSizeDistribution(int min, int max) {
      this.min = min;
      this.max = max;
    }

    public int chooseSize(Random random) {
      return random.nextInt(max - min + 1) + min;
    }
  }

  private BenchmarkHelpers() {}

  @Override
  public Set<N> successors(N node) {
    return delegate().successors(node);
  }

  @Override
  public int degree(N node) {
    return delegate().degree(node);
  }

  @Override
  public int inDegree(N node) {
    return delegate().inDegree(node);
  }

  @Override
  public int outDegree(N node) {
    return delegate().outDegree(node);
  }

  @Override