Server Building

/**
 * Create a server builder that will bind with the given name.
 * @param name the identity of the server for clients to connect to
 * @return a new builder
 */
public static InProcessServerBuilder forName(String name);

/**
 * Create a server builder which listens on the given address.
 * @param listenAddress The SocketAddress this server will listen on
 * @return a new builder
 */
public static InProcessServerBuilder forAddress(SocketAddress listenAddress);

/**
 * Generates a new server name that is unique each time.
 * @return a unique server name (UUID string)
 */
public static String generateName();

// Create named server
InProcessServerBuilder builder1 = InProcessServerBuilder.forName("my-service");

// Create server with socket address
InProcessSocketAddress address = new InProcessSocketAddress("service-name");
InProcessServerBuilder builder2 = InProcessServerBuilder.forAddress(address);

// Generate unique name for testing
String uniqueName = InProcessServerBuilder.generateName();
InProcessServerBuilder builder3 = InProcessServerBuilder.forName(uniqueName);

/**
 * Sets the maximum size of metadata allowed to be received.
 * @param bytes the maximum size of received metadata
 * @return this builder
 * @throws IllegalArgumentException if bytes is non-positive
 */
public InProcessServerBuilder maxInboundMetadataSize(int bytes);

/**
 * Provides a custom scheduled executor service.
 * @param scheduledExecutorService the scheduled executor service to use
 * @return this builder
 */
public InProcessServerBuilder scheduledExecutorService(
    ScheduledExecutorService scheduledExecutorService);

/**
 * Provides a custom deadline ticker for creating incoming Deadlines.
 * Intended for unit tests that fake out the clock. DO NOT use in production.
 * @param ticker the deadline ticker to use
 * @return this builder
 */
public InProcessServerBuilder deadlineTicker(Deadline.Ticker ticker);

/**
 * TLS is not supported in InProcessServer.
 * @param certChain certificate chain file
 * @param privateKey private key file
 * @return this builder
 * @throws UnsupportedOperationException always thrown
 */
public InProcessServerBuilder useTransportSecurity(File certChain, File privateKey);

import io.grpc.inprocess.InProcessServerBuilder;
import io.grpc.Server;
import java.util.concurrent.TimeUnit;

// Generate unique name for testing
String serverName = InProcessServerBuilder.generateName();

// Build and start server
Server server = InProcessServerBuilder.forName(serverName)
    .addService(new MyGrpcServiceImpl()) // Add your gRPC service implementations
    .addService(new AnotherServiceImpl())
    .maxInboundMetadataSize(8192) // Set metadata size limit
    .directExecutor() // Use direct executor for testing
    .build();

// Start the server
server.start();

// Server is now available for in-process connections using serverName

// Shutdown gracefully
server.shutdown();
try {
    if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
        server.shutdownNow();
    }
} catch (InterruptedException e) {
    server.shutdownNow();
    Thread.currentThread().interrupt();
}

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class MyServiceTest {
    private Server server;
    private Channel channel;
    private String serverName;

    @BeforeEach
    void setUp() throws Exception {
        // Generate unique server name for each test
        serverName = InProcessServerBuilder.generateName();
        
        // Create and start server
        server = InProcessServerBuilder.forName(serverName)
            .directExecutor()
            .addService(new MyServiceImpl())
            .build()
            .start();
        
        // Create client channel
        channel = InProcessChannelBuilder.forName(serverName)
            .directExecutor()
            .build();
    }

    @AfterEach
    void tearDown() throws Exception {
        if (channel instanceof ManagedChannel) {
            ((ManagedChannel) channel).shutdownNow();
        }
        if (server != null) {
            server.shutdownNow();
        }
    }

    @Test
    void testMyService() {
        MyServiceGrpc.MyServiceBlockingStub stub = 
            MyServiceGrpc.newBlockingStub(channel);
        
        MyResponse response = stub.myMethod(
            MyRequest.newBuilder().setMessage("test").build()
        );
        
        assertThat(response.getResult()).isEqualTo("expected");
    }
}