queryLambda.callback(cq);
        final Collection<FilterFunctionBuilder> list = new ArrayList<>();
        if (functionsLambda != null) {
            functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
                RelatedQueryCQ cf = new RelatedQueryCQ();
                cqLambda.callback(cf);
                list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
            });
        }

        queryLambda.callback(cq);
        final Collection<FilterFunctionBuilder> list = new ArrayList<>();
        if (functionsLambda != null) {
            functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
                RoleTypeCQ cf = new RoleTypeCQ();
                cqLambda.callback(cf);
                list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
            });
        }

    UNIFORM_0_TO_2(0, 2),
    UNIFORM_0_TO_9(0, 9),
    ALWAYS_0(0, 0),
    ALWAYS_10(10, 10);

    final int min;
    final int max;

    ListSizeDistribution(int min, int max) {
      this.min = min;
      this.max = max;
    }

    public int chooseSize(Random random) {
      return random.nextInt(max - min + 1) + min;
    }
  }

  private BenchmarkHelpers() {}

    private String realm = null;
    /** The service principal name */
    private String service = DEFAULT_SERVICE;
    /** The user credential lifetime */
    private int userLifetime = GSSCredential.DEFAULT_LIFETIME;
    /** The security context lifetime */
    private int contextLifetime = GSSContext.DEFAULT_LIFETIME;
    /** Flag indicating if fallback authentication is allowed */
    private boolean canFallback = false;

            validator.validatePath("\\share\\other\\file.txt");
            fail("Should block non-whitelisted path");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("not in allowed list"));
        }
    }

    @Test
    public void testBlacklistPriority() throws Exception {
        // Add to both blacklist and whitelist
        validator.addToBlacklist("\\share\\test");

    const TF_Graph* fn_body, const char* fn_name, int ninputs,
    const TF_Output* inputs, std::vector<OutputTensor>* input_tensors,
    std::unordered_map<const Node*, std::vector<int>>* input_nodes)
    TF_EXCLUSIVE_LOCKS_REQUIRED(fn_body->mu) {
  input_tensors->reserve(ninputs);
  for (int i = 0; i < ninputs; ++i) {
    Node* node = inputs[i].oper ? &inputs[i].oper->node : nullptr;
    int idx = inputs[i].index;

    protected boolean allowLeadingWildcard = true;

    /** The default operator to use between query terms */
    protected Operator defaultOperator = Operator.AND;

    /** List of filters to apply to queries */
    protected List<Filter> filterList = new ArrayList<>();

    /** The filter chain used to process queries */
    protected FilterChain filterChain;

    /**

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.testing.NullPointerTester;
import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;

/**
 * Unit test for {@link Strings}.
 *
 * @author Kevin Bourrillion
 */
@NullMarked
@GwtCompatible
public class StringsTest extends TestCase {
  public void testNullToEmpty() {
    assertEquals("", Strings.nullToEmpty(null));

import com.google.common.collect.Iterables;
import com.google.common.primitives.Ints;
import com.google.common.testing.NullPointerTester;
import java.util.List;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link Throwables}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@SuppressWarnings("deprecation") // tests of numerous deprecated methods
@NullUnmarked

import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link Closer}.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class CloserTest extends TestCase {