public int size() {
      return IntMath.saturatedAdd(rest.length, 2);
    }

    @Override
    @ParametricNullness
    public E get(int index) {
      switch (index) {
        case 0:
          return first;
        case 1:
          return second;
        default:
          // check explicitly so the IOOBE will have the right message
          checkElementIndex(index, size());
          return rest[index - 2];

            String value = props.getProperty("test.prop");
            if (value == null) {
                // If not found, it means ComponentUtil.getSystemProperties() is not returning system properties
                // In that case, just check that the file was created
                assertTrue(propFile.exists());
            } else {
                assertEquals("test.value", value);
            }
        }

        // Clean up

    }

    return response.socket
      ?: throw ProtocolException("Web Socket socket missing: bad interceptor?")
  }

  /**
   * This accepts a [BufferedSource] instead of using [Socket.source], just in case we've already
   * received data from the peer. This accepts a [BufferedSink] for symmetry with the source.
   */
  fun initReaderAndWriter(
    name: String,
    socket: BufferedSocket,
    client: Boolean,

          if (expectedMessage != null) {
            assertThat(expected).hasMessageThat().isEqualTo(expectedMessage);
          }
        }
      }
    },
    /*
     * This one comes last to work around b/367716565. (One *possible* alternative would be to not
     * declare any methods in this enum, converting assertFailsToDecode into a static method that is
     * implemented with a `switch`. I haven't tested that.)

 * Set}, respectively.
 *
 * <p>For example, the "presidents" code snippet above used a {@code ListMultimap}; if it had used a
 * {@code SetMultimap} instead, two presidents would have vanished, and last names might or might
 * not appear in chronological order.
 *
 * <p><b>Warning:</b> instances of type {@code Multimap} may not implement {@link Object#equals} in

        }
    }

    /**
     * Tests for edge cases and error conditions
     */
    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle null configuration gracefully")
        void testNullConfiguration() {
            // When & Then - Should not throw exception

          "[h2_prior_knowledge, http/1.1]",
      )
    }
  }

  @Test
  fun testH2PriorKnowledgeServerDuplicates() {
    try {
      // Treating this use case as user error
      server.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.H2_PRIOR_KNOWLEDGE)
      fail<Unit>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo(

```Python hl_lines="4"
{!> ../../docs_src/python_types/tutorial006.py!}
```

////

/// info | Información

Esos tipos internos en los corchetes se denominan "parámetros de tipo".

En este caso, `str` es el parámetro de tipo pasado a `List` (o `list` en Python 3.9 y superior).

///

Eso significa: "la variable `items` es una `list`, y cada uno de los ítems en esta lista es un `str`".

/// tip | Consejo

Remote ARN = 'arn:minio:replication:us-east-1:c5be6b16-769d-432a-9ef1-4567081f3566:destbucket'

*   Include unit tests when you contribute new features, as they help to a)
    prove that your code works correctly, and b) guard against future breaking
    changes to lower the maintenance cost.
*   Bug fixes also generally require unit tests, because the presence of bugs
    usually indicates insufficient test coverage.
*   Keep API compatibility in mind when you change code in core TensorFlow,
    e.g., code in