var tmpdir string

var (
	devID    string
	appID    string
	teamID   string
	bundleID string
	deviceID string
)

// lock is a file lock to serialize iOS runs. It is global to avoid the
// garbage collector finalizing it, closing the file and releasing the
// lock prematurely.
var lock *os.File

func main() {
	log.SetFlags(0)
	log.SetPrefix("go_ios_exec: ")
	if debug {
		log.Println(strings.Join(os.Args, " "))
	}

import static org.mockito.Mockito.verify;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.Configuration;

class NameQueryRequestTest {

    @Mock
    private Configuration mockConfig;
    @Mock
    private Name mockName;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

      id: filter
      with:
        filters: |
          docs:
            - README.md
            - docs/**
            - docs_src/**
            - pyproject.toml
            - uv.lock
            - mkdocs.yml
            - mkdocs.env.yml
            - .github/workflows/build-docs.yml
            - .github/workflows/deploy-docs.yml
            - scripts/mkdocs_hooks.py
  langs:
    needs:

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class SmbComSessionSetupAndXTest {

    @Mock
    private CIFSContext mockContext;
    @Mock
    private SmbComNegotiateResponse mockNegotiate;
    @Mock
    private ServerMessageBlock mockAndX;
    @Mock
    private Configuration mockConfig;

    private static byte[] blobCred() {
        return "blobdata".getBytes(StandardCharsets.UTF_8);

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class CIFSContextCredentialWrapperTest {

    @Mock
    private AbstractCIFSContext mockDelegate;
    @Mock
    private Credentials mockCredentials;
    @Mock
    private SmbRenewableCredentials mockRenewableCredentials;
    @Mock
    private CredentialsInternal mockRenewedCredentialsInternal;
    @Mock
    private NtlmAuthenticator mockNtlmAuthenticator;
    @Mock

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

/**
 * Tests for the NdrObject abstract class.
 * This test uses a concrete implementation to verify the abstract contract.
 */
@ExtendWith(MockitoExtension.class)
class NdrObjectTest {

    @Mock
    private NdrBuffer mockBuffer;

    private ConcreteNdrObject ndrObject;

            interfaceType,
            delegate -> {
              T mock = mock(forwarderClass, CALLS_REAL_METHODS);
              try {
                T stubber = doReturn(delegate).when(mock);
                DELEGATE_METHOD.invoke(stubber);
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
              return mock;
            });
  }

  private ForwardingObjectTester() {}

@NullMarked
public class TestLogHandler extends Handler {
  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }

            interfaceType,
            delegate -> {
              T mock = mock(forwarderClass, CALLS_REAL_METHODS);
              try {
                T stubber = doReturn(delegate).when(mock);
                DELEGATE_METHOD.invoke(stubber);
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
              return mock;
            });
  }

  private ForwardingObjectTester() {}