holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {
            return 1;
          }
        };

    builder.put(entry);
    holder.string = "two";

     * @throws JobProcessingException if the script explicitly throws this exception
     *         (allows scripts to signal job-specific errors that should propagate)
     */
    @Override
    public Object evaluate(final String template, final Map<String, Object> paramMap) {
        // Null-safety: return null for blank templates
        // Early return is safe here as no resources have been allocated yet

    }
  }

  private enum PlatformSpecificExceptionBatch {
    PLATFORM {
      @GwtIncompatible
      @J2ktIncompatible
      @Override
      // returns the types available in "normal" environments
      ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> exceptions() {
        return ImmutableMap.of(
            InvocationTargetException.class,

 * limitations under the License.
 */

package gradlebuild.binarycompatibility

class JavaxAnnotationNullabilityChangesTest : AbstractJavaNullabilityChangesTest() {
    override val nullableAnnotationName: String = "javax.annotation.Nullable"

     */
    public void setSuppliedWorkstation(final String suppliedWorkstation) {
        this.suppliedWorkstation = suppliedWorkstation;
    }

    @Override
    public byte[] toByteArray() {
        try {
            final String suppliedDomain = getSuppliedDomain();
            final String suppliedWorkstation = getSuppliedWorkstation();
            int flags = getFlags();

     * Gets the expanded names array for this referral.
     *
     * @return the expandedNames
     */
    public final String[] getExpandedNames() {
        return this.expandedNames;
    }

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        this.version = SMBUtil.readInt2(buffer, bufferIndex);

def test_router_ws_depends_with_override():
    client = TestClient(app)
    app.dependency_overrides[ws_dependency] = lambda: "Override"  # noqa: E731
    with client.websocket_connect("/router-ws-depends/") as websocket:
        assert websocket.receive_text() == "Override"


def test_router_with_params():
    client = TestClient(app)
    with client.websocket_connect(

     * @param len the length of data to decode
     * @return the number of bytes decoded
     * @throws SMBProtocolDecodingException if the data cannot be properly decoded
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        bufferIndex++; // revision
        bufferIndex++;

    val callback: ServerSentEventReader.Callback =
      object : ServerSentEventReader.Callback {
        override fun onEvent(
          id: String?,
          type: String?,
          data: String,
        ) {
          callbacks.add(Event(id, type, data))
        }

        override fun onRetryChange(timeMs: Long) {
          callbacks.add(timeMs)
        }
      }

    new IteratorTester<E>(
        Platform.collectionIteratorTesterNumIterations(), features, elements, knownOrder) {
      @Override
      protected Iterator<E> newTargetIterator() {
        resetCollection();
        return collection.iterator();
      }

      @Override
      protected void verify(List<E> elements) {
        expectContents(elements);
      }
    }.test();
  }