«Менеджери контексту» - це будь-які Python-об'єкти, які можна використовувати в операторі `with`.

Наприклад, [можна використати `with`, щоб прочитати файл](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):

```Python
with open("./somefile.txt") as f:
    contents = f.read()
    print(contents)
```

Під капотом `open("./somefile.txt")` створює об'єкт, який називається «Менеджер контексту».

        String queryString = result.toString();
        // Should have both readings
        assertTrue("Should contain original text", queryString.contains("test"));
        assertTrue("Should contain converted reading", queryString.contains("test_reading"));
    }

    @Test
    public void test_buildQuery_threeWords() {
        QueryBuilder result = request.buildQuery("one two three", Collections.emptyList());

labels.jobStatus=Status
labels.labelTypeIds=Labels
labels.lang=Language
labels.outputs=Outputs
labels.pos=Part-of-speech
labels.purgeJobLogDay=Delete old job logs
labels.purgeUserInfoDay=Delete old user logs
labels.reading=Reading
labels.roleTypeIds=Role IDs
labels.scriptData=Script
labels.scriptResult=Result
labels.scriptType=Execution Method
labels.segmentation=Segmentation
labels.startTime=Start Time
labels.target=Target

  private ExceptionTypePolicy policy = ExceptionTypePolicy.NPE_OR_UOE;

  /*
   * Requiring desugaring for guava-*testlib* is likely safe, at least for the reflection-based
   * NullPointerTester. But if you are a user who is reading this because this change caused you
   * trouble, please let us know: https://github.com/google/guava/issues/new
   */
  @IgnoreJRERequirement
  public NullPointerTester() {
    try {
      /*

            // for proper cleanup, so we don't return early here
            Clock global = getClock(GLOBAL);
            global.start();
            lock.readLock().lock();
            try {
                // Process build steps in a logical order:
                // 1. Find steps that are not yet started (CREATED status)

				return
			}
		case "ForwardTo":
			z.ForwardTo, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ForwardTo")
				return
			}
		case "Limit":
			z.Limit, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Limit")
				return
			}
		case "DiskID":
			z.DiskID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "DiskID")
				return
			}

      } finally {
        lock.unlock();
      }
    }

    @Override
    public boolean awaitUntil(Date deadline) throws InterruptedException {
      lock.lock();
      try {
        return condition.awaitUntil(deadline);
      } finally {
        lock.unlock();
      }
    }

    @Override
    public void signal() {
      lock.lock();

      return null // Another edit is in progress.
    }

    if (entry != null && entry.lockingSourceCount != 0) {
      return null // We can't write this file because a reader is still reading it.
    }

    if (mostRecentTrimFailed || mostRecentRebuildFailed) {
      // The OS has become our enemy! If the trim job failed, it means we are storing more data than

                    final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(con.getOutputStream(), Constants.CHARSET_UTF_8))) {
                String line;
                while ((line = br.readLine()) != null) {
                    if (StringUtil.isNotBlank(line)) {
                        final Map<String, Map<String, String>> dataObj;
                        if (line.contains("\"_index\"") || line.contains("\"_type\"")) {

     * @throws CIFSException if an error occurs accessing the resource
     */
    OutputStream openOutputStream() throws CIFSException;

    /**
     * Opens an input stream reading the file (read only)
     *
     * @param flags
     *            open flags
     * @param access
     *            desired access flags
     * @param sharing