// version or alter its lock settings unless they have special
			// permissions. With governance mode, you protect objects against
			// being deleted by most users, but you can still grant some users
			// permission to alter the retention settings or delete the object
			// if necessary. You can also use governance mode to test retention-period
			// settings before creating a compliance-mode retention period.

// formValues is the already-canonicalized form values from the POST request.
func checkPostPolicy(formValues http.Header, postPolicyForm PostPolicyForm) error {
	// Check if policy document expiry date is still not reached
	if !postPolicyForm.Expiration.After(UTCNow()) {
		return fmt.Errorf("Invalid according to Policy: Policy expired")
	}

	// mustFindInPolicy is a map to list all the keys that we must find in the policy as

    // ... trigger server failover ...
    
    // Verify that witness notification was received and handled
    assertTrue(listener.waitForNotification(30000));  // 30 second timeout
    
    // Verify file is still accessible after failover
    assertTrue(file.exists());
}

@Test
public void testWitnessServiceDiscovery() throws Exception {
    CIFSContext context = getTestContext();

 *             loadExceptionCount} are incremented, and the total loading time, in nanoseconds, is
 *             added to {@code totalLoadTime}.
 *         <li>Cache lookups that encounter a missing cache entry that is still loading will wait
 *             for loading to complete (whether successful or not) and then increment {@code
 *             missCount}.
 *       </ul>

 *             loadExceptionCount} are incremented, and the total loading time, in nanoseconds, is
 *             added to {@code totalLoadTime}.
 *         <li>Cache lookups that encounter a missing cache entry that is still loading will wait
 *             for loading to complete (whether successful or not) and then increment {@code
 *             missCount}.
 *       </ul>

	if errMetaCode != ErrNone {
		return errMetaCode
	}

	// If the host which signed the request is slightly ahead in time (by less than globalMaxSkewTime) the
	// request should still be allowed.
	if pSignValues.Date.After(UTCNow().Add(globalMaxSkewTime)) {
		return ErrRequestNotReadyYet
	}

	if UTCNow().Sub(pSignValues.Date) > pSignValues.Expires {
		return ErrExpiredPresignRequest
	}

        assertNotNull(respCap.getValue(), "Expected SmbComBlankResponse");

        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close() does not send when invalid but still releases")
    void close_invalid_doesNotSend_butReleases() throws CIFSException {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(3L, true, true);

        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, () -> handle.release());
        assertTrue(ex.getMessage().contains("below zero"));
        verify(treeConnection, times(1)).release(); // still only once
    }

    @Test
    @DisplayName("acquire after release reacquires underlying tree connection")
    void acquireAfterReleaseReacquires() {

   * <p>Whenever possible, it is preferable to test directly for some observable change resulting
   * from GC, as with {@link #awaitClear}. Because there are no guarantees for the order of GC
   * finalization processing, there may still be some unfinished work for the GC to do after this
   * method returns.
   *
   * <p>This method does not create any memory pressure as would be required to cause soft
   * references to be processed.
   *

	}

	// Verify the unlinked pet still exists in the database using real database query
	var count int64
	if err := DB.Model(&Pet{}).Where("id = ?", petToUnlink.ID).Count(&count).Error; err != nil {
		t.Fatalf("failed to count pet: %v", err)
	}
	if count != 1 {
		t.Error("unlinked pet should still exist in database")
	}
}