}

func (d *naughtyDisk) Close() (err error) {
	if err = d.calcError(); err != nil {
		return err
	}
	return d.disk.Close()
}

func (d *naughtyDisk) calcError() (err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.callNR++
	if err, ok := d.errors[d.callNR]; ok {
		return err
	}
	if d.defaultErr != nil {
		return d.defaultErr
	}
	return nil
}

           * load our class directly (which would trigger non-reflective loading of VarHandle) from
           * within a `try` block, then an error might be thrown even before we enter the `try`
           * block: https://github.com/google/truth/issues/333#issuecomment-765652454
           *
           * Also, it's nice that this approach should let us catch *only* ClassNotFoundException

        streamId = 0,
        length = 0,
        type = TYPE_SETTINGS,
        flags = FLAG_ACK,
      )
      sink.flush()
    }
  }

  /**
   * HTTP/2 only. Send a push promise header block.
   *
   * A push promise contains all the headers that pertain to a server-initiated request, and a
   * `promisedStreamId` to which response frames will be delivered. Push promise frames are sent as

              if (System.nanoTime() - t0 > timeout) {
                thrown.set(
                    new TimeoutException(
                        "timed out waiting for other threads to block"
                            + " synchronizing on supplier"));
                break;
              }
              Thread.yield();
            }
            count.getAndIncrement();

              if (System.nanoTime() - t0 > timeout) {
                thrown.set(
                    new TimeoutException(
                        "timed out waiting for other threads to block"
                            + " synchronizing on supplier"));
                break;
              }
              Thread.yield();
            }
            count.getAndIncrement();

      total += read;
      Java8Compatibility.clear(buf);
    }
    return total;
  }

  /**
   * Discards {@code n} characters of data from the reader. This method will block until the full
   * amount has been skipped. Does not close the reader.
   *
   * @param reader the reader to read from
   * @param n the number of characters to skip

				w.Header()[xhttp.AmzObjectTagging] = []string{objInfo.UserTags}
			}
		}
	}

	// Set all other user defined metadata.
	for k, v := range objInfo.UserDefined {
		// Empty values for object lock and retention can be skipped.
		if v == "" && equals(k, xhttp.AmzObjectLockMode, xhttp.AmzObjectLockRetainUntilDate) {
			continue
		}

		if stringsHasPrefixFold(k, ReservedMetadataPrefixLower) {

			return true
		}

		if nerr, ok := err.(*net.OpError); ok {
			return (nerr.Err.Error() == "use of closed network connection")
		}

		return false
	}

	target.connMutex.Lock()
	defer target.connMutex.Unlock()

	if target.conn != nil {
		ch, err = target.conn.Channel()
		if err == nil {
			if target.args.PublisherConfirms {

  "email": "******@****.***",
  "full_name": "John Doe",
  "disabled": false,
  "hashed_password": "fakehashedsecret"
}
```

<img src="/img/tutorial/security/image06.png">

If you click the lock icon and logout, and then try the same operation again, you will get an HTTP 401 error of:

```JSON
{
  "detail": "Not authenticated"
}
```

### Inactive user { #inactive-user }

	return func(endpoint Endpoint, err error, once bool) {
		reqInfo := (&logger.ReqInfo{}).AppendTags("endpoint", endpoint.String())
		ctx := logger.SetReqInfo(GlobalContext, reqInfo)
		mutex.Lock()
		defer mutex.Unlock()

		m, ok := printOnce[endpoint]
		if !ok {
			m = make(map[string]int)
			printOnce[endpoint] = m
			if once {
				m[err.Error()]++
				peersLogAlwaysIf(ctx, err)
				return