public class SamrAliasHandle extends rpc.policy_handle {

    DcerpcHandle handle;

    public SamrAliasHandle(DcerpcHandle handle,
                SamrDomainHandle domainHandle,
                int access,
                int rid) throws IOException {
        this.handle = handle;
        MsrpcSamrOpenAlias rpc = new MsrpcSamrOpenAlias(domainHandle, access, rid, this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0)

public class TestLogHandlerTest extends TestCase {

  private TestLogHandler handler;
  private TearDownStack stack = new TearDownStack();

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    handler = new TestLogHandler();

    // You could also apply it higher up the Logger hierarchy than this
    ExampleClassUnderTest.logger.addHandler(handler);

    eventBus.post(EVENT);

    assertEquals("Cause should be available.", exception, handler.exception);
    assertEquals("EventBus should be available.", eventBus, handler.context.getEventBus());
    assertEquals("Event should be available.", EVENT, handler.context.getEvent());
    assertEquals("Subscriber should be available.", subscriber, handler.context.getSubscriber());
    assertEquals(
        "Method should be available.",

It's almost the only thing that you have to remember to do correctly yourself, to be compliant with the specifications.

For the rest, **FastAPI** handles it for you.

///

## Update the dependencies

Now we are going to update our dependencies.

We want to get the `current_user` *only* if this user is active.

import jcifs.dcerpc.msrpc.lsarpc.LsarClose;


/**
 * 
 */
public class MsrpcLsarClose extends LsarClose {

    /**
     * @param handle
     */
    public MsrpcLsarClose ( policy_handle handle ) {
        super(handle);
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

	[op(0x01)]
	int SamrCloseHandle([in] policy_handle *handle);

	[op(0x39)]
	int SamrConnect2([in,string,unique] wchar_t *system_name,
			[in] uint32_t access_mask,
			[out] policy_handle *handle);

	[op(0x3e)]
	int SamrConnect4([in,string,unique] wchar_t *system_name,
			[in] uint32_t unknown,
			[in] uint32_t access_mask,
			[out] policy_handle *handle);

	[op(0x07)]
	int SamrOpenDomain([in] policy_handle *handle,

			closer.Close()
		}
	})
}

// NoAuthMiddleware no auth middle ware.
func NoAuthMiddleware(h http.Handler) http.Handler {
	return h
}

// AuthMiddleware checks if the bearer token is valid and authorized.
func AuthMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

import java.util.List;
import java.util.logging.Handler;
import java.util.logging.LogRecord;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Tests may use this to intercept messages that are logged by the code under test. Example:
 *
 * <pre>
 *   TestLogHandler handler;
 *
 *   protected void setUp() throws Exception {
 *     super.setUp();
 *     handler = new TestLogHandler();

            }
            final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();
            final CorsHandler handler = factory.get(origin);
            if (handler != null) {
                handler.process(origin, request, response);

                if (OPTIONS.equals(httpRequest.getMethod())) {

        }

        public int retval;
        public rpc.policy_handle handle;


        public LsarClose ( rpc.policy_handle handle ) {
            this.handle = handle;
        }


        @Override
        public void encode_in ( NdrBuffer _dst ) throws NdrException {
            this.handle.encode(_dst);
        }


        @Override