System.arraycopy(name.getBytes("US-ASCII"), 0, src, srcIndex + 1 + (i * 18), 16);
            src[srcIndex + 1 + (i * 18) + 15] = (byte) i; // Different hex codes
            src[srcIndex + 1 + (i * 18) + 16] = 0x04; // Active flag
        }

        // MAC address
        int macOffset = srcIndex + 1 + (18 * numNames);

        // Test equality with same password
        assertEquals(auth1, auth2);
        assertEquals(auth1.hashCode(), auth2.hashCode());

        // Test inequality with different password
        assertNotEquals(auth1, auth3);

        // Test after password wipe
        auth1.secureWipePassword();
        assertNotEquals(auth1, auth2);
    }

    /**

                int expectedSize = copy.size();
                int actualEncoded = copy.encode(buffer, 0);

                // Then
                assertEquals(expectedSize, actualEncoded, "Size and encode methods return different values for " + numChunks + " chunks");
            }
        }

        @Test
        @DisplayName("Should handle large number of chunks")
        void testLargeNumberOfChunks() {
            // Given

* And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`.

{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}

There are 2 main differences from a normal *path operation*:

* It doesn't need to have any actual code, because your app will never call this code. It's only used to document the *external API*. So, the function could just have `pass`.

   * invokeAll/invokeAny} throwing RejectedExecutionException, although a subset of the tasks may
   * already have been executed.
   *
   * @since 32.0.0 (taking the place of a method with a different return type from 15.0)
   */
  public static ListeningScheduledExecutorService sameThreadScheduledExecutor() {
    return new SameThreadScheduledExecutorService();
  }

    assertThat(thread2.getName().substring(0, thread.getName().lastIndexOf('-')))
        .isEqualTo(thread.getName().substring(0, thread.getName().lastIndexOf('-')));

    // Building again should give us a different pool ID.
    ThreadFactory threadFactory2 = builder.build();
    Thread thread3 = threadFactory2.newThread(monitoredRunnable);
    checkThreadPoolName(thread3, 1);

    char[] charsB = new char[128];

    for (int i = 0; i < charsA.length; i++) {
      if (i < 100) {
        charsA[i] = 'a';
        charsB[i] = 'a';
      } else {
        // Both two-byte characters, but must be different
        charsA[i] = (char) (0x0180 + i);
        charsB[i] = (char) (0x0280 + i);
      }
    }

    String stringA = new String(charsA);
    String stringB = new String(charsB);

        // Now set a new instance
        LogStream.setInstance(testStream);
        LogStream instance2 = LogStream.getInstance();
        assertNotNull(instance2);

        // Should be different instances since setInstance replaces the previous one
        assertNotSame(instance1, instance2);
        // Getting instance again should return the same as instance2
        assertSame(instance2, LogStream.getInstance());

La manière de décrire cela dans OpenAPI est de marquer ce champ comme **requis**, car il sera toujours présent.

Pour cette raison, le schéma JSON d'un modèle peut être différent selon qu'il est utilisé pour **l'entrée ou la sortie** :

- pour **l'entrée**, `description` ne sera **pas requis**
- pour **la sortie**, il sera **requis** (et éventuellement `None`, ou en termes JSON, `null`)

  virtual absl::Status Reset(const char* op, const char* raw_device_name) = 0;

  virtual const string& Name() const = 0;

  // Returns the operation's device name.
  //
  // The value returned may be different from the one set by SetDeviceName, but
  // it will be compatible with it: the name will be updated by device placement
  // logic to refer to the specific device chosen.
  //