// Arrange: mock and stub each getter with distinct values
        SmbBasicFileInfo mock = Mockito.mock(SmbBasicFileInfo.class);
        Mockito.when(mock.getAttributes()).thenReturn(7);
        Mockito.when(mock.getCreateTime()).thenReturn(11L);
        Mockito.when(mock.getLastWriteTime()).thenReturn(13L);
        Mockito.when(mock.getLastAccessTime()).thenReturn(17L);

				"x-amz-object-lock-mode":              "governance",
				"x-amz-object-lock-retain-until-date": "2020-02-01",
			},
			expected:        map[string]string{},
			filterRetention: true,
			filterLegalHold: true,
		},
		{
			metadata: map[string]string{
				"x-amz-object-lock-legal-hold":        "on",
				"x-amz-object-lock-mode":              "governance",

    @Test
    void testLsarLookupSidsConstructorAndGetOpnum() {
        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);
        lsarpc.LsarSidArray mockSids = mock(lsarpc.LsarSidArray.class);
        lsarpc.LsarRefDomainList mockDomains = mock(lsarpc.LsarRefDomainList.class);
        lsarpc.LsarTransNameArray mockNames = mock(lsarpc.LsarTransNameArray.class);

            });
        }
    }

    @Test
    @DisplayName("Mockito mock of WinError")
    void mockInterfaceNoOps() {
        WinError mock = Mockito.mock(WinError.class);
        assertNotNull(mock);
        assertTrue(Mockito.mockingDetails(mock).isMock(), "Object should be a Mockito mock");
        Mockito.verifyNoInteractions(mock);
    }

            SmbSession mockSession = mock(SmbSession.class);
            Configuration mockConfig = mock(Configuration.class);

            // Only mock getConfig, leave others with default behavior
            when(mockSession.getConfig()).thenReturn(mockConfig);

            assertEquals(mockConfig, mockSession.getConfig());
            assertNull(mockSession.getContext()); // Default mock behavior

    for (int i = 0; i < reps; i++) {
      lock.lock();
      lock.unlock();
    }
  }

  @Benchmark
  void orderedPlainLocks(int reps) {
    lockAndUnlockNested(plainLocks, reps);
  }

  @Benchmark
  void orderedCycleDetectingLocks(int reps) {
    lockAndUnlockNested(detectingLocks, reps);
  }

  private static void lockAndUnlockNested(Lock[] locks, int reps) {

```sh
aws s3api put-object --bucket testbucket --key lockme --object-lock-mode GOVERNANCE --object-lock-retain-until-date "2019-11-20"  --body /etc/issue
```

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.calls;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;

/**
 * @author Sebastien Doyon
 */
class DefaultClassRealmManagerTest {

    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    Funnels.byteArrayFunnel().funnel(new byte[] {4, 3, 2, 1}, primitiveSink);
    verify(primitiveSink).putBytes(new byte[] {4, 3, 2, 1});
  }

  public void testForBytes_null() {
    assertNullsThrowException(Funnels.byteArrayFunnel());
  }

  public void testForStrings() {
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package lock

import (
	"os"
	"testing"
	"time"
)

// Test lock fails.
func TestLockFail(t *testing.T) {
	f, err := os.CreateTemp(t.TempDir(), "lock")
	if err != nil {
		t.Fatal(err)
	}
	f.Close()
	defer func() {
		err = os.Remove(f.Name())
		if err != nil {
			t.Fatal(err)