}

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~

        assertEquals("", emptyEvent.getEventType());
    }

    // Test multiple implementations
    @Test
    public void test_multipleImplementations() {
        // Create different implementations
        SearchLogEvent event1 = new TestSearchLogEvent("id1", 1L, "type1");
        SearchLogEvent event2 = new NullSearchLogEvent();
        SearchLogEvent event3 = new EmptySearchLogEvent();

        paramMap.put("items", items);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertTrue(result.toString().contains("item1"));
    }

    // Test evaluate method returns different object type
    @Test
    public void test_evaluate_returnsObject() {
        scriptEngine = new ObjectReturningScriptEngine();
        String template = "return object";

        // context.highlightedQuerySet and context.fieldLogMap remain null,
        // so context updates cannot be verified. This is expected behavior.
    }

    /**
     * Test convertWithFieldCheck() with different boost values.
     */
    @Test
    public void test_convertWithFieldCheck_withDifferentBoosts() {
        FessConfig fessConfig = ComponentUtil.getFessConfig();

    serverCert =
      HeldCertificate
        .Builder()
        .signedBy(serverIntermediateCa)
        .serialNumber(3L)
        .commonName(server.hostName)
        .addSubjectAlternativeName("different-host.com")
        .build()
    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)

        assertEquals(0, result);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100 })
    @DisplayName("writeBytesWireFormat should work at different offsets")
    void testWriteBytesWireFormatAtDifferentOffsets(int offset) {
        byte[] buffer = new byte[512];

        int written = request.writeBytesWireFormat(buffer, offset);

        byte[] buffer = new byte[16];

        // Test edge of array
        SMBUtil.writeInt2(0xFFFF, buffer, 14);
        assertEquals(0xFFFF, SMBUtil.readInt2(buffer, 14));

        // Test different offsets
        for (int offset = 0; offset <= 8; offset++) {
            SMBUtil.writeInt4(0x12345678, buffer, offset);
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, offset));
        }
    }

        final CurlRequest request2 = Curl.get("http://example.com");

        // ## Assert ##
        assertNotNull(request1);
        assertNotNull(request2);
        assertTrue("Factory methods should return different instances", request1 != request2);
    }

    @Test
    public void test_ProtectedConstructor() throws Exception {
        // ## Test that protected constructor can be accessed via reflection ##

import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Base class for tests for emulated {@link AbstractFuture} that allow subclasses to swap in a
 * different "source Future" for {@link AbstractFuture#setFuture} calls.
 */
@GwtCompatible
@NullUnmarked
abstract class AbstractAbstractFutureTest extends TestCase {
  @SuppressWarnings("initialization.field.uninitialized")

<img src="/img/tutorial/generate-clients/image05.png">

## FastAPI App with Tags { #fastapi-app-with-tags }

In many cases, your FastAPI app will be bigger, and you will probably use tags to separate different groups of *path operations*.

For example, you could have a section for **items** and another section for **users**, and they could be separated by tags:

{* ../../docs_src/generate_clients/tutorial002_py310.py hl[21,26,34] *}