// jar "a" has a transitive dependency on 2.0 of jar "b", but maven should
    // prefer to use version 1.0.
    //
    // ----------------------------------------------------------------------

    @Test
    void testDependencyManagementOverridesTransitiveDependencyVersion() throws Exception {
        File localRepo = getLocalRepositoryPath();
        File pom0 = new File(localRepo, "p0/pom.xml");

                            + ", enable verbose output (-X) for more details");
                }
            }
        }

        return false;
    }

    public void enableLogging(Logger logger) {
        this.logger = logger;
    }

  AbstractTensorHandleKind getKind() const { return kind_; }

 private:
  const AbstractTensorHandleKind kind_;
};

namespace internal {
struct AbstractTensorHandleDeleter {
  void operator()(AbstractTensorHandle* p) const {
    if (p != nullptr) {
      p->Unref();
    }
  }
};
}  // namespace internal

// TODO(b/185908092): Make AbstractTensorHandlePtr an IntrusivePtr.

    }

    private Set<CtMethod> collectAllPublicApiMethods(CtClass c) {
        Set<CtMethod> result = [] as Set
        collect(result, c)
        return result
    }

    private void collect(Set<CtMethod> result, CtClass c) {
        if (c == null) {
            return
        }

        result.addAll(c.declaredMethods.findAll { isPublicApi(it) })

        collect(result, c.superclass)
    }

    return delegate().getAll(keys);
  }

  @Override
  public V apply(K key) {
    return delegate().apply(key);
  }

  @Override
  public void refresh(K key) {
    delegate().refresh(key);
  }

  /**
   * A simplified version of {@link ForwardingLoadingCache} where subclasses can pass in an already
   * constructed {@link LoadingCache} as the delegate.
   *

        Predicates.<Entry<K, V>>and(
            multimap.entryPredicate(), Maps.<V>valuePredicateOnEntries(not(Predicates.in(c)))));
  }

  @Override
  public void clear() {
    multimap.clear();
  }

    public abstract Property<String> getInputEncoding();

    /**
     * Encoding of output file
     */
    @Input
    public abstract Property<String> getOutputEncoding();

    @TaskAction
    public void process() {
        MutableDataSet options = new MutableDataSet();
        options.set(Parser.EXTENSIONS, Collections.singletonList(TablesExtension.create()));
        Parser parser = Parser.builder(options).build();

/**
 * @author codelibs
 * @author Keiichi Watanabe
 */
public class AdminLogAction extends FessAdminAction {

    public static final String ROLE = "admin-log";

    @Override
    protected void setupHtmlData(final ActionRuntime runtime) {
        super.setupHtmlData(runtime);
        runtime.registerData("helpLink", systemHelper.getHelpLink(fessConfig.getOnlineHelpNameLog()));
    }

    @Override

      }
    };

    abstract Striped<Lock> get(int stripes);
  }

  private Striped<Lock> striped;
  private int[] stripes;
  private List<Integer> bulkGetSet;

  @BeforeExperiment
  void setUp() {
    this.striped = impl.get(numStripes);
    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);

      }
    };

    abstract Striped<Lock> get(int stripes);
  }

  private Striped<Lock> striped;
  private int[] stripes;
  private List<Integer> bulkGetSet;

  @BeforeExperiment
  void setUp() {
    this.striped = impl.get(numStripes);
    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);