ret=$?
if [ $ret -ne 0 ]; then
	echo "BUG: PutObject to bucket: test-bucket should succeed. Failed"
	exit 1
fi

mc cp /etc/issue myminio1/multi-key-poc | grep -q "Insufficient permissions to access this path"
ret=$?
if [ $ret -eq 0 ]; then
	echo "BUG: PutObject to bucket: multi-key-poc without sse-kms should fail. Succedded"
	exit 1
fi

                        throw new RuntimeException("Even call error");
                    }
                    // Odd calls succeed
                }
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // First call (odd) should succeed
        String result1 = aggregateLogJob.execute();
        assertEquals("", result1);

        // Second call (even) should fail

    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .addHeader("Content-Type: text/plain")
        .build(),
    )

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()

 *  * Preemptive proxy authentication failed.
 *
 * Planning failures are not necessarily fatal. For example, even if we can't DNS lookup the first
 * proxy in a list, looking up a subsequent one may succeed.
 */
internal class FailedPlan(
  e: Throwable,
) : RoutePlanner.Plan {
  val result = RoutePlanner.ConnectResult(plan = this, throwable = e)

  override val isReady = false

	}
	gr, err := obj.GetObjectNInfo(ctx, bucket, object, nil, nil, ObjectOptions{})
	if err != nil {
		t.Fatalf("Expected GetObject to succeed, but failed with %v", err)
	}
	output := bytes.NewBuffer([]byte{})
	_, err = io.Copy(output, gr)
	if err != nil {
		t.Fatalf("Expected GetObject reading data to succeed, but failed with %v", err)
	}
	gr.Close()
	if !bytes.Equal(output.Bytes(), smallData) {
		t.Fatalf("Corrupted data is found")

		host, port, err := extractHostPort(testCase.addr)
		if testCase.expectedErr == nil && err != nil {
			t.Fatalf("Test %d: should succeed but failed with err: %v", i+1, err)
		}
		if testCase.expectedErr != nil && err == nil {
			t.Fatalf("Test %d:, should fail but succeeded.", i+1)
		}
		if err == nil {
			if host != testCase.host {
				t.Fatalf("Test %d: expected: %v, found: %v", i+1, testCase.host, host)
			}

    }

    @Test
    void testTreeConnectAndDisconnect() throws Exception {
        SmbTree tree = new SmbTree(session, "testShare", "testService");

        // Mock transport.connect() to succeed
        doNothing().when(transport).connect();

        // Setup response for tree connect
        doAnswer(invocation -> {
            ServerMessageBlock request = invocation.getArgument(0);

        executor.shutdown();

        // Then - All operations should succeed
        assertTrue(exceptions.isEmpty(), "No exceptions should occur");
        assertEquals(threadCount * opsPerThread, successCount.get(), "All operations should succeed");
    }

    /**
     * Test that buffer cache handles allocation when cache is full.
     */
    @Test

        if (!exceptions.isEmpty()) {
            fail("Concurrent operations caused exceptions: " + exceptions.get(0));
        }

        assertEquals(threadCount * opsPerThread, successCount.get(), "All operations should succeed");
    }

    /**
     * Test that session release with double-check pattern prevents race conditions.
     */
    @Test
    public void testSessionReleaseDoubleCheckPattern() throws Exception {

        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "First attempt should be allowed");

        // Record success
        rateLimiter.recordSuccess("user1", "192.168.1.1");

        // Should still be allowed
        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "After success should be allowed");
    }

    @Test
    public void testAccountLockout() throws Exception {