@BeforeEach
    void setUp() {
        dfsResolver = new DfsImpl(mockContext);
        when(mockContext.getConfig()).thenReturn(mockConfig);
    }

    // Test for isTrustedDomain method
    @Test
    void testIsTrustedDomain_DfsDisabled() throws CIFSException {
        when(mockConfig.isDfsDisabled()).thenReturn(true);
        assertFalse(dfsResolver.isTrustedDomain(mockContext, "anyDomain"));
    }

  // via delegate()); it seems inappropriate to throw ISE on this method.
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  private void validate() {
    // Don't use checkState(), because we don't want the overhead of generating the error message
    // unless it's actually going to be used; validate() is called for all set method calls, so it
    // needs to be fast.

 * limitations under the License.
 */

package com.google.common.eventbus;

import com.google.common.testing.AbstractPackageSanityTests;
import java.lang.reflect.Method;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Basic sanity tests for the entire package.
 *
 * @author Ben Yu
 */

@NullUnmarked

                "The 'next' property of the appended referral should point back to the initial referral, closing the loop.");
    }

    /**
     * Tests the toString method of the DfsReferral class.
     * It verifies that the toString method returns a string representation of the object
     * that accurately reflects its properties.
     */
    @Test
    void testToString() {
        // Given

  /**
   * Verifies that a collection is immutable.
   *
   * <p>A collection is considered immutable if:
   *
   * <ol>
   *   <li>All its mutation methods result in UnsupportedOperationException, and do not change the
   *       underlying contents.
   *   <li>All methods that return objects that can indirectly mutate the collection throw
   *       UnsupportedOperationException when those mutators are called.
   * </ol>
   *

    }

    // instance method ignored
    public Object badIgnored() {
      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    // non-public method ignored
    static Object badButNotPublic() {

         */
        public SearchResultBuilder addDocument(final Map<String, Object> doc) {
            documentList.add(doc);
            return this;
        }

        /**
         * Sets the facet response containing aggregated facet information.
         *
         * @param facetResponse The facet response
         * @return This builder instance for method chaining
         */

		subrouter.Methods(http.MethodPost).Path("/v1/health").HandlerFunc(lockServer.HealthHandler)
		subrouter.Methods(http.MethodPost).Path("/v1/refresh").HandlerFunc(lockServer.RefreshHandler)
		subrouter.Methods(http.MethodPost).Path("/v1/lock").HandlerFunc(lockServer.LockHandler)
		subrouter.Methods(http.MethodPost).Path("/v1/rlock").HandlerFunc(lockServer.RLockHandler)

/**
 * Marks an event subscriber method as being thread-safe. This annotation indicates that EventBus
 * may invoke the event subscriber simultaneously from multiple threads.
 *
 * <p>This does not mark the method, and so should be used in combination with {@link Subscribe}.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)

            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change."
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

    @Test