*
   * <p>This method always throws an exception. The {@code RuntimeException} return type allows
   * client code to signal to the compiler that statements after the call are unreachable. Example
   * usage:
   *
   * <pre>
   * T doSomething() {
   *   try {
   *     return someMethodThatCouldThrowAnything();
   *   } catch (IKnowWhatToDoWithThisException e) {

            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(1, SMBUtil.readInt2(buffer, 2)); // Lock count

            // Verify lock sequence (bits 4-7 are sequence number, bits 0-27 are index)
            int lockSequence = SMBUtil.readInt4(buffer, 4);
            assertEquals(0, lockSequence); // Default values

            // Verify file ID

他们将收到一条错误响应，表明字段 `extra` 不被允许：

```json
{
    "detail": [
        {
            "type": "extra_forbidden",
            "loc": ["body", "extra"],
            "msg": "Extra inputs are not permitted",
            "input": "Mr. Poopybutthole"
        }
    ]
}
```

## 总结 { #summary }

    public OptionalEntity<WebAuthentication> getWebAuthentication(final String id) {
        return webAuthenticationBhv.selectByPK(id);
    }

    /**
     * Stores a web authentication configuration.
     * Parameters are encrypted before storage.
     *
     * @param webAuthentication The web authentication configuration to store
     */
    public void store(final WebAuthentication webAuthentication) {

  <description>
    Contains
    com.google.common.util.concurrent.internal.InternalFutureFailureAccess and
    InternalFutures. Most users will never need to use this artifact. Its
    classes are conceptually a part of Guava, but they're in this separate
    artifact so that Android libraries can use them without pulling in all of
    Guava (just as they can use ListenableFuture by depending on the

  multiple drives into a single large system, pass one directory per
  filesystem separated by space. You may also use a '...' convention
  to abbreviate the directory arguments. Remote directories in a
  distributed setup are encoded as HTTP(s) URIs.
{{if .VisibleFlags}}
FLAGS:
  {{range .VisibleFlags}}{{.}}
  {{end}}{{end}}
EXAMPLES:

	return &Reader{
		args:       args,
		decoder:    d,
		valueCh:    d.Stream(),
		readCloser: readCloser,
	}
}

// syncReadCloser will wrap a readcloser and make it safe to call Close while
// reads are running.
type syncReadCloser struct {
	rc io.ReadCloser
	mu sync.Mutex
}

func (pr *syncReadCloser) Read(p []byte) (n int, err error) {
	// This ensures that Close will block until Read has completed.

        for (Platform platform : Platform.values()) {
            for (boolean bundledJdk : new boolean[] { true, false }) {
                // create a new project in each iteration, so that we know we are resolving the only additional project being created
                Project project = createProject(BWC_MINOR);
                String projectName = projectName(platform.toString(), bundledJdk);

  }

  /**
   * Tests for Predicates.instanceOf(x). TODO: Fix the comment style after fixing annotation
   * stripper to remove comments properly. Currently, all tests before the comments are removed as
   * well.
   */
  @GwtIncompatible // Predicates.instanceOf
  public void testIsInstanceOf_apply() {
    Predicate<@Nullable Object> isInteger = Predicates.instanceOf(Integer.class);

            loggedExec.doFirst(new Action<Task>() {
                @Override
                public void execute(Task t) {
                    // Execution time so that the checkouts are available
                    String compilerVersionInfoPath = minimumCompilerVersionPath(unreleasedVersionInfo.get().version);