*/
    protected abstract List<Float> create(Float[] elements);

    @Override
    public Float[] createArray(int length) {
      return new Float[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Float> order(List<Float> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleFloats extends SampleElements<Float> {

     */
    protected abstract List<Integer> create(Integer[] elements);

    @Override
    public Integer[] createArray(int length) {
      return new Integer[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Integer> order(List<Integer> insertionOrder) {
      return insertionOrder;
    }
  }

				t.Errorf("Test %d: failed to write data blocks: %v", i, err)
			}
			if !bytes.Equal(decodedData.Bytes(), data) {
				t.Errorf("Test %d: Decoded data does not match original data: got: %v want: %v", i, decodedData.Bytes(), data)
			}
		}
	}
}

// Setup for erasureCreateFile and erasureReadFile tests.
type erasureTestSetup struct {
	dataBlocks   int
	parityBlocks int

Este método devuelve una función. Y esa función es la que recibirá un request y devolverá un response.

Aquí lo usamos para crear un `GzipRequest` a partir del request original.

{* ../../docs_src/custom_request_and_route/tutorial001.py hl[18:26] *}

/// note | Detalles técnicos

// Len returns the number of bytes of the unread portion of the
// slice.
func (r *Reader) Len() int {
	if r.i >= int64(len(r.s)) {
		return 0
	}
	return int(int64(len(r.s)) - r.i)
}

// Size returns the original length of the underlying byte slice.
// Size is the number of bytes available for reading via [Reader.ReadAt].
// The result is unaffected by any method calls except [Reader.Reset].

   * comparator is not <i>consistent with equals</i>), the results of this method are undefined.
   *
   * <p>The returned {@code BiMap} iterates over entries in the same order as the {@code entrySet}
   * of the original map.
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are

We can declare all that without having to modify the original `APIRouter` by passing those parameters to `app.include_router()`:

```Python hl_lines="14-17" title="app/main.py"
{!../../docs_src/bigger_applications/app/main.py!}
```

+ Create a topic branch from where you want to base your work (this is usually the master branch).
  Push your changes to a topic branch in your fork of the repository.
+ Make commits of logical units.
+ Respect the original code style: by using the same [codestyle][code-style],
  patches should only highlight the actual difference, not being disturbed by any formatting issues:
  + Only use spaces for indentation.

    return HASH_FN.hashBytes(bytes, 0, length).asLong();
  }

  /**
   * Tests that the Java port of Fingerprint2011 provides the same results on buffers up to 800
   * bytes long as the original implementation in C++. See http://cl/106539598
   */
  public void testMultipleLengths() {
    int iterations = 800;
    byte[] buf = new byte[iterations * 4];
    int bufLen = 0;
    long h = 0;

        }
        return getSupportedLanguage(result.getLanguage());
    }

    /**
     * Returns the text to be used for language detection.
     *
     * @param text The original text.
     * @return The text for language detection.
     */
    protected String getDetectText(final String text) {
        final String result;
        if (text.length() <= maxTextLength) {