Java Code Examples for com.google.common.collect.ImmutableSortedSet

The following examples show how to use com.google.common.collect.ImmutableSortedSet. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
Source Project: buck   Source File: FileBundler.java    License: Apache License 2.0 6 votes vote down vote up
public void copy(
    ProjectFilesystem filesystem,
    BuildCellRelativePathFactory buildCellRelativePathFactory,
    ImmutableList.Builder<Step> steps,
    Path destinationDir,
    ImmutableSortedSet<SourcePath> toCopy,
    SourcePathResolverAdapter pathResolver) {
  copy(
      filesystem,
      buildCellRelativePathFactory,
      steps,
      destinationDir,
      toCopy,
      pathResolver,
      PatternsMatcher.NONE);
}
 
Example 2
Source Project: buck   Source File: IncrementalActionGraphScenarioTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testCxxBinaryAndGenruleLoadedFromCache() {
  BuildTarget genruleTarget = BuildTargetFactory.newInstance("//:gen");
  GenruleBuilder genruleBuilder =
      GenruleBuilder.newGenruleBuilder(genruleTarget).setCmd("cmd").setOut("out");

  BuildTarget binaryTarget = BuildTargetFactory.newInstance("//:bin");
  CxxBinaryBuilder binaryBuilder =
      new CxxBinaryBuilder(binaryTarget)
          .setHeaders(ImmutableSortedSet.of(DefaultBuildTargetSourcePath.of(genruleTarget)))
          .setSrcs(
              ImmutableSortedSet.of(
                  SourceWithFlags.of(FakeSourcePath.of("binary.cpp"), ImmutableList.of())));

  ActionGraphAndBuilder result = createActionGraph(binaryBuilder, genruleBuilder);
  queryTransitiveDeps(result);
  ImmutableMap<BuildRule, RuleKey> ruleKeys = getRuleKeys(result);
  ActionGraphAndBuilder newResult = createActionGraph(binaryBuilder, genruleBuilder);
  queryTransitiveDeps(newResult);
  ImmutableMap<BuildRule, RuleKey> newRuleKeys = getRuleKeys(newResult);

  assertBuildRulesSame(result, newResult);
  assertEquals(ruleKeys, newRuleKeys);
}
 
Example 3
Source Project: bazel   Source File: ConfigCommand.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns the {@link Fragment}s and the {@link FragmentOptions} they require from Blaze's
 * runtime.
 *
 * <p>These are the fragments that Blaze "knows about", not necessarily the fragments in a {@link
 * BuildConfiguration}. Trimming, in particular, strips fragments out of actual configurations.
 * It's safe to assume untrimmed configuration have all fragments listed here.
 */
private static ImmutableSortedMap<
        Class<? extends Fragment>, ImmutableSortedSet<Class<? extends FragmentOptions>>>
    getFragmentDefs(ConfiguredRuleClassProvider ruleClassProvider) {
  ImmutableSortedMap.Builder<
          Class<? extends Fragment>, ImmutableSortedSet<Class<? extends FragmentOptions>>>
      fragments = ImmutableSortedMap.orderedBy((c1, c2) -> c1.getName().compareTo(c2.getName()));
  for (ConfigurationFragmentFactory fragmentFactory :
      ruleClassProvider.getConfigurationFragments()) {
    fragments.put(
        fragmentFactory.creates(),
        ImmutableSortedSet.copyOf(
            (c1, c2) -> c1.getName().compareTo(c2.getName()), fragmentFactory.requiredOptions()));
  }
  return fragments.build();
}
 
Example 4
Source Project: n4js   Source File: ConcurrentIssueRegistry.java    License: Eclipse Public License 1.0 6 votes vote down vote up
public boolean clearIssuesOfPersistedState(String containerHandle) {
	List<IssueRegistryChangeEvent> events;
	synchronized (this) {
		Map<URI, ImmutableSortedSet<LSPIssue>> containerIssues = getContainerIssues(containerHandle, false);
		if (containerIssues == null) {
			return false;
		}
		events = containerIssues.entrySet().stream()
				.map(e -> eventPersisted(containerHandle, e.getKey(), e.getValue(), null))
				.collect(Collectors.toList());
		containerIssues.keySet().forEach(persistedIssues::remove);
		container2persistedIssues.remove(containerHandle);
	}
	notifyListeners(events);
	return true;
}
 
Example 5
Source Project: buck   Source File: RustLibraryDescriptionTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testGeneratedSourceFromCxxGenrule() throws NoSuchBuildTargetException {
  CxxGenruleBuilder srcBuilder =
      new CxxGenruleBuilder(BuildTargetFactory.newInstance("//:src")).setOut("lib.rs");
  RustLibraryBuilder libraryBuilder =
      RustLibraryBuilder.from("//:lib")
          .setSrcs(
              ImmutableSortedSet.of(DefaultBuildTargetSourcePath.of(srcBuilder.getTarget())));
  RustBinaryBuilder binaryBuilder =
      RustBinaryBuilder.from("//:bin")
          .setSrcs(ImmutableSortedSet.of(FakeSourcePath.of("main.rs")))
          .setDeps(ImmutableSortedSet.of(libraryBuilder.getTarget()));
  TargetGraph targetGraph =
      TargetGraphFactory.newInstance(
          srcBuilder.build(), libraryBuilder.build(), binaryBuilder.build());
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);
  graphBuilder.requireRule(binaryBuilder.getTarget());
}
 
Example 6
Source Project: bazel   Source File: SdkMavenRepository.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Parses a set of maven repository directory trees looking for and parsing .pom files.
 */
static SdkMavenRepository create(Iterable<Path> mavenRepositories) throws IOException {
  Collection<Path> pomPaths = new ArrayList<>();
  for (Path mavenRepository : mavenRepositories) {
    pomPaths.addAll(
        FileSystemUtils.traverseTree(mavenRepository, path -> path.toString().endsWith(".pom")));
  }

  ImmutableSortedSet.Builder<Pom> poms =
      new ImmutableSortedSet.Builder<>(Ordering.usingToString());
  for (Path pomPath : pomPaths) {
    try {
      Pom pom = Pom.parse(pomPath);
      if (pom != null) {
        poms.add(pom);
      }
    } catch (ParserConfigurationException | SAXException e) {
      throw new IOException(e);
    }
  }
  return new SdkMavenRepository(poms.build());
}
 
Example 7
Source Project: activitystreams   Source File: BoundingBox.java    License: Apache License 2.0 6 votes vote down vote up
protected static BoundingBox calculateBoundingBoxLineStrings(Iterable<LineString> lineStrings) {
  ImmutableSortedSet.Builder<Float> xset = 
    ImmutableSortedSet.naturalOrder();
  ImmutableSortedSet.Builder<Float> yset = 
      ImmutableSortedSet.naturalOrder();
  ImmutableSortedSet.Builder<Float> zset = 
      ImmutableSortedSet.naturalOrder();
  for (LineString ls : lineStrings) {
    for (Position p : ls) {
      xset.add(p.northing());
      yset.add(p.easting());
      if (p.hasAltitude())
        zset.add(p.altitude());
    }
  }
  return buildBoundingBox(
    xset.build(), 
    yset.build(), 
    zset.build());
}
 
Example 8
Source Project: buck   Source File: PrebuiltCxxLibraryDescriptionTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void exportedHeaders() {
  ProjectFilesystem filesystem = new AllExistingProjectFilesystem();
  PrebuiltCxxLibraryBuilder libBuilder =
      new PrebuiltCxxLibraryBuilder(TARGET)
          .setExportedHeaders(
              SourceSortedSet.ofNamedSources(
                  ImmutableSortedMap.of("foo.h", FakeSourcePath.of("foo.h"))));
  TargetGraph targetGraph = TargetGraphFactory.newInstance(libBuilder.build());
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);
  PrebuiltCxxLibrary lib =
      (PrebuiltCxxLibrary) libBuilder.build(graphBuilder, filesystem, targetGraph);

  // Verify the preprocessable input is as expected.
  CxxPreprocessorInput input = lib.getCxxPreprocessorInput(CXX_PLATFORM, graphBuilder);
  assertThat(getHeaderNames(input.getIncludes()), Matchers.hasItem(filesystem.getPath("foo.h")));
  assertThat(
      ImmutableSortedSet.copyOf(input.getDeps(graphBuilder)),
      Matchers.equalTo(graphBuilder.getAllRules(getInputRules(lib))));
}
 
Example 9
Source Project: armeria   Source File: ServiceInfo.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Merges the {@link MethodInfo}s with the same method name and {@link HttpMethod} pair
 * into a single {@link MethodInfo}. Note that only the {@link EndpointInfo}s are merged
 * because the {@link MethodInfo}s being merged always have the same
 * {@code exampleHttpHeaders} and {@code exampleRequests}.
 */
@VisibleForTesting
static Set<MethodInfo> mergeEndpoints(Iterable<MethodInfo> methodInfos) {
    final Map<List<Object>, MethodInfo> methodInfoMap = new HashMap<>();
    for (MethodInfo methodInfo : methodInfos) {
        final List<Object> mergeKey = ImmutableList.of(methodInfo.name(), methodInfo.httpMethod());
        methodInfoMap.compute(mergeKey, (key, value) -> {
            if (value == null) {
                return methodInfo;
            } else {
                final Set<EndpointInfo> endpointInfos =
                        Sets.union(value.endpoints(), methodInfo.endpoints());
                return new MethodInfo(value.name(), value.returnTypeSignature(),
                                      value.parameters(), value.exceptionTypeSignatures(),
                                      endpointInfos, value.exampleHttpHeaders(),
                                      value.exampleRequests(), value.examplePaths(), value.exampleQueries(),
                                      value.httpMethod(), value.docString());
            }
        });
    }
    return ImmutableSortedSet
            .orderedBy(comparing(MethodInfo::name).thenComparing(MethodInfo::httpMethod))
            .addAll(methodInfoMap.values())
            .build();
}
 
Example 10
Source Project: bazel   Source File: NinjaGraphArtifactsHelper.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Constructor
 *
 * @param ruleContext parent NinjaGraphRule rule context
 * @param outputRootPath name of output directory for Ninja actions under execroot
 * @param workingDirectory relative path under execroot, the root for interpreting all paths in
 *     Ninja file
 * @param symlinkPathToArtifact mapping of paths to artifacts for input symlinks under output_root
 * @param outputRootSymlinks list of output paths for which symlink artifacts should be created,
 *     paths are relative to the output_root.
 */
NinjaGraphArtifactsHelper(
    RuleContext ruleContext,
    PathFragment outputRootPath,
    PathFragment workingDirectory,
    ImmutableSortedMap<PathFragment, Artifact> symlinkPathToArtifact,
    ImmutableSortedSet<PathFragment> outputRootSymlinks) {
  this.ruleContext = ruleContext;
  this.outputRootPath = outputRootPath;
  this.workingDirectory = workingDirectory;
  this.symlinkPathToArtifact = symlinkPathToArtifact;
  this.outputRootSymlinks = outputRootSymlinks;
  Path execRoot =
      Preconditions.checkNotNull(ruleContext.getConfiguration())
          .getDirectories()
          .getExecRoot(ruleContext.getWorkspaceName());
  this.derivedOutputRoot =
      ArtifactRoot.asDerivedRoot(execRoot, outputRootPath.getSegments().toArray(new String[0]));
  this.sourceRoot = ruleContext.getRule().getPackage().getSourceRoot().get();
}
 
Example 11
Source Project: buck   Source File: Cells.java    License: Apache License 2.0 6 votes vote down vote up
/** @return Path of the topmost cell's path that roots all other cells */
public AbsPath getSuperRootPath() {
  AbsPath cellRoot = getRootCell().getRoot();
  ImmutableSortedSet<AbsPath> allRoots = getRootCell().getKnownRootsOfAllCells();
  AbsPath path = cellRoot.getRoot();

  // check if supercell is a root folder, like '/' or 'C:\'
  if (allRoots.contains(path)) {
    return path;
  }

  // There is an assumption that there is exactly one cell with a path that prefixes all other
  // cell paths. So just try to find the cell with the shortest common path.
  for (Path next : cellRoot.getPath()) {
    path = path.resolve(next);
    if (allRoots.contains(path)) {
      return path;
    }
  }
  throw new IllegalStateException(
      "Unreachable: at least one path should be in getKnownRoots(), including root cell '"
          + cellRoot.toString()
          + "'; known roots = ["
          + allRoots.stream().map(Objects::toString).collect(Collectors.joining(", "))
          + "]");
}
 
Example 12
Source Project: buck   Source File: AndroidBinaryFilesInfoTest.java    License: Apache License 2.0 6 votes vote down vote up
FakePreDexMerge(BuildTarget buildTarget, APKModuleGraph apkModuleGraph) {
  super(
      buildTarget,
      new FakeProjectFilesystem(),
      new BuildRuleParams(
          ImmutableSortedSet::of, ImmutableSortedSet::of, ImmutableSortedSet.of()),
      null,
      "dx",
      new DexSplitMode(
          /* shouldSplitDex */ true,
          DexSplitStrategy.MINIMIZE_PRIMARY_DEX_SIZE,
          DexStore.JAR,
          /* linearAllocHardLimit */ 4 * 1024 * 1024,
          /* primaryDexPatterns */ ImmutableSet.of("List"),
          Optional.of(FakeSourcePath.of("the/manifest.txt")),
          /* primaryDexScenarioFile */ Optional.empty(),
          /* isPrimaryDexScenarioOverflowAllowed */ false,
          /* secondaryDexHeadClassesFile */ Optional.empty(),
          /* secondaryDexTailClassesFile */ Optional.empty(),
          /* allowRDotJavaInSecondaryDex */ false),
      apkModuleGraph,
      null,
      MoreExecutors.newDirectExecutorService(),
      XzStep.DEFAULT_COMPRESSION_LEVEL,
      Optional.empty());
}
 
Example 13
Source Project: n4js   Source File: ConcurrentIssueRegistry.java    License: Eclipse Public License 1.0 5 votes vote down vote up
public void setIssuesOfPersistedState(String containerHandle, URI uri, Iterable<? extends LSPIssue> issues) {
	ImmutableSortedSet<LSPIssue> issuesNew = ImmutableSortedSet.copyOf(issueComparator, issues);
	ImmutableSortedSet<LSPIssue> issuesOld;
	synchronized (this) {
		Map<URI, ImmutableSortedSet<LSPIssue>> containerIssues = getContainerIssues(containerHandle, true);
		persistedIssues.put(uri, issuesNew);
		issuesOld = containerIssues.put(uri, issuesNew);
	}
	notifyListeners(eventPersisted(containerHandle, uri, issuesOld, issuesNew));
}
 
Example 14
Source Project: buck   Source File: PythonTestDescriptionTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void platformDeps() throws IOException {
  SourcePath libASrc = FakeSourcePath.of("libA.py");
  PythonLibraryBuilder libraryABuilder =
      PythonLibraryBuilder.createBuilder(BuildTargetFactory.newInstance("//:libA"))
          .setSrcs(SourceSortedSet.ofUnnamedSources(ImmutableSortedSet.of(libASrc)));
  SourcePath libBSrc = FakeSourcePath.of("libB.py");
  PythonLibraryBuilder libraryBBuilder =
      PythonLibraryBuilder.createBuilder(BuildTargetFactory.newInstance("//:libB"))
          .setSrcs(SourceSortedSet.ofUnnamedSources(ImmutableSortedSet.of(libBSrc)));
  PythonTestBuilder binaryBuilder =
      PythonTestBuilder.create(BuildTargetFactory.newInstance("//:bin"))
          .setPlatformDeps(
              PatternMatchedCollection.<ImmutableSortedSet<BuildTarget>>builder()
                  .add(
                      Pattern.compile(
                          CxxPlatformUtils.DEFAULT_PLATFORM_FLAVOR.toString(), Pattern.LITERAL),
                      ImmutableSortedSet.of(libraryABuilder.getTarget()))
                  .add(
                      Pattern.compile("matches nothing", Pattern.LITERAL),
                      ImmutableSortedSet.of(libraryBBuilder.getTarget()))
                  .build());
  TargetGraph targetGraph =
      TargetGraphFactory.newInstance(
          libraryABuilder.build(), libraryBBuilder.build(), binaryBuilder.build());
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);
  PythonTest test = (PythonTest) graphBuilder.requireRule(binaryBuilder.getTarget());
  assertThat(
      test.getBinary()
          .getComponents()
          .resolve(graphBuilder.getSourcePathResolver())
          .getAllModules()
          .values(),
      Matchers.allOf(
          Matchers.hasItem(graphBuilder.getSourcePathResolver().getAbsolutePath(libASrc)),
          Matchers.not(
              Matchers.hasItem(graphBuilder.getSourcePathResolver().getAbsolutePath(libBSrc)))));
}
 
Example 15
Source Project: buck   Source File: AndroidBinaryNonExoInstaller.java    License: Apache License 2.0 5 votes vote down vote up
protected AndroidBinaryNonExoInstaller(
    BuildTarget buildTarget, ProjectFilesystem projectFilesystem, HasInstallableApk apk) {
  super(buildTarget, projectFilesystem);
  Preconditions.checkState(!apk.getApkInfo().getExopackageInfo().isPresent());
  this.trigger = new InstallTrigger(projectFilesystem);
  this.apk = apk;
  this.depsSupplier = MoreSuppliers.memoize(() -> ImmutableSortedSet.of((BuildRule) apk));
}
 
Example 16
Source Project: batfish   Source File: WorkMgr.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * List questions for the given network and analysis. Returns list of questions if successful, or
 * {@code null} if network or analysis does not exist.
 */
public @Nullable SortedSet<String> listAnalysisQuestions(String network, String analysis) {
  Optional<NetworkId> networkIdOpt = _idManager.getNetworkId(network);
  if (!networkIdOpt.isPresent()) {
    return null;
  }
  NetworkId networkId = networkIdOpt.get();
  Optional<AnalysisId> analysisIdOpt = _idManager.getAnalysisId(analysis, networkId);
  if (!analysisIdOpt.isPresent()) {
    return null;
  }
  return ImmutableSortedSet.copyOf(_idManager.listQuestions(networkId, analysisIdOpt.get()));
}
 
Example 17
Source Project: buck   Source File: JavaTestIntegrationTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testClasspath() throws IOException {
  ProjectWorkspace workspace =
      TestDataHelper.createProjectWorkspaceForScenario(this, "test_rule_classpath", temp);
  workspace.setUp();
  ProcessResult result = workspace.runBuckCommand("audit", "classpath", "//:top");
  result.assertSuccess();
  ImmutableSortedSet<Path> actualPaths =
      FluentIterable.from(Arrays.asList(result.getStdout().split("\\s+")))
          .transform(input -> temp.getRoot().relativize(Paths.get(input)))
          .toSortedSet(Ordering.natural());
  ImmutableSortedSet<Path> expectedPaths =
      ImmutableSortedSet.of(
          BuildTargetPaths.getGenPath(
                  workspace.getProjectFileSystem(),
                  BuildTargetFactory.newInstance("//:top"),
                  "lib__%s__output")
              .resolve("top.jar"),
          BuildTargetPaths.getGenPath(
                  workspace.getProjectFileSystem(),
                  BuildTargetFactory.newInstance("//:direct_dep"),
                  "lib__%s__output")
              .resolve("direct_dep.jar"),
          BuildTargetPaths.getGenPath(
                  workspace.getProjectFileSystem(),
                  BuildTargetFactory.newInstance("//:mid_test#testsjar"),
                  "lib__%s__output")
              .resolve("mid_test#testsjar.jar"),
          BuildTargetPaths.getGenPath(
                  workspace.getProjectFileSystem(),
                  BuildTargetFactory.newInstance("//:transitive_lib"),
                  "lib__%s__output")
              .resolve("transitive_lib.jar"));
  assertEquals(expectedPaths, actualPaths);
}
 
Example 18
Source Project: batfish   Source File: TopologyUtilTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testComputeVniInterNodeEdges() {
  String s1Name = "S1";
  String s2Name = "S2";
  int vlanId = 2;
  int vni = 10002;
  String vrfName = "v1";
  Configuration s1 = _cb.setHostname(s1Name).build();
  Configuration s2 = _cb.setHostname(s2Name).build();
  Vrf v1 = _vb.setOwner(s1).setName(vrfName).build();
  Vrf v2 = _vb.setOwner(s2).setName(vrfName).build();
  Layer2Vni.Builder vnb =
      testBuilder()
          .setBumTransportIps(ImmutableSortedSet.of(Ip.FIRST_MULTICAST_IP))
          .setBumTransportMethod(BumTransportMethod.MULTICAST_GROUP)
          .setVlan(vlanId)
          .setVni(vni);
  v1.addLayer2Vni(vnb.build());
  v2.addLayer2Vni(vnb.build());
  String vniName = computeVniName(vni);

  MutableGraph<VxlanNode> graph = GraphBuilder.undirected().allowsSelfLoops(false).build();
  graph.putEdge(new VxlanNode(s1Name, vni), new VxlanNode(s2Name, vni));
  VxlanTopology vxlanTopology = new VxlanTopology(graph);
  Layer2Node n1 = new Layer2Node(s1Name, vniName, null);
  Layer2Node n2 = new Layer2Node(s2Name, vniName, null);

  assertThat(
      computeVniInterNodeEdges(vxlanTopology).collect(ImmutableList.toImmutableList()),
      containsInAnyOrder(new Layer2Edge(n1, n2, null), new Layer2Edge(n2, n1, null)));
}
 
Example 19
Source Project: buck   Source File: ShTestDescriptionTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void resourcesAreInputs() throws Exception {
  BuildTarget target = BuildTargetFactory.newInstance("//:rule");
  ProjectFilesystem filesystem = new FakeProjectFilesystem();
  Path resource = filesystem.getPath("resource");
  filesystem.touch(resource);
  TargetNode<?> shTestWithResources =
      new ShTestBuilder(target)
          .setTest(FakeSourcePath.of(filesystem, "some_test"))
          .setResources(ImmutableSortedSet.of(PathSourcePath.of(filesystem, resource)))
          .build();
  assertThat(
      shTestWithResources.getInputs(), Matchers.hasItem(ForwardRelativePath.ofPath(resource)));
}
 
Example 20
Source Project: batfish   Source File: NamedStructureEquivalenceSets.java    License: Apache License 2.0 5 votes vote down vote up
public void addEntry(
    String structureName, String hostname, T structure, boolean assumeAllUnique) {
  Map<Integer, Set<NamedStructureEquivalenceSet<T>>> sameNamedStructuresByHash =
      _sameNamedStructuresByNameAndHash.computeIfAbsent(structureName, s -> new HashMap<>());
  String structureJson = writeObject(structure);
  int hash = structureJson.hashCode();
  Set<NamedStructureEquivalenceSet<T>> eqSetsWithSameHash =
      sameNamedStructuresByHash.computeIfAbsent(hash, h -> new HashSet<>());
  if (assumeAllUnique || eqSetsWithSameHash.isEmpty()) {
    eqSetsWithSameHash.add(new NamedStructureEquivalenceSet<>(hostname, structure));
  } else {
    Optional<NamedStructureEquivalenceSet<T>> potentialMatchingSet =
        eqSetsWithSameHash.stream()
            .filter(
                s -> checkJsonStringEquals(structureJson, writeObject(s.getNamedStructure())))
            .findAny();
    if (potentialMatchingSet.isPresent()) {
      NamedStructureEquivalenceSet<T> matchingSet = potentialMatchingSet.get();
      matchingSet.setNodes(
          new ImmutableSortedSet.Builder<String>(Comparator.naturalOrder())
              .addAll(matchingSet.getNodes())
              .add(hostname)
              .build());
    } else {
      eqSetsWithSameHash.add(new NamedStructureEquivalenceSet<>(hostname, structure));
    }
  }
}
 
Example 21
private void setup_internalNHIp_subnetNotFull_internalDstIp() {
  Configuration node1 = _cb.setHostname(NODE1).build();
  Vrf vrf = _vb.setOwner(node1).setName(Configuration.DEFAULT_VRF_NAME).build();
  _ib.setOwner(node1).setVrf(vrf);
  _ib.setName(NEXT_HOP_INTERFACE).setAddresses(NEXT_HOP_INTERFACE_NOT_FULL_ADDR).build();

  // setup a loopback on NODE2 that owns NEXT_HOP_IP and DST_IP
  Configuration node2 = _cb.setHostname(NODE2).build();
  Vrf vrf2 = _vb.setOwner(node2).build();
  _ib.setOwner(node2)
      .setVrf(vrf2)
      .setName(LOOPBACK_INTERFACE)
      .setAddresses(
          ConcreteInterfaceAddress.create(DST_IP, 32),
          ConcreteInterfaceAddress.create(NEXT_HOP_IP, 32))
      .build();

  vrf.setStaticRoutes(
      ImmutableSortedSet.of(
          StaticRoute.builder()
              .setNetwork(DST_IP.toPrefix())
              .setNextHopInterface(NEXT_HOP_INTERFACE)
              .setNextHopIp(NEXT_HOP_IP)
              .setAdministrativeCost(1)
              .build()));
  _configs = ImmutableSortedMap.of(NODE1, node1, NODE2, node2);
}
 
Example 22
Source Project: bazel   Source File: ImmutableSortedSetCodecTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void unknowComparatorThrows() {
  assertThrows(
      SerializationException.class,
      () ->
          TestUtils.roundTrip(
              ImmutableSortedSet.orderedBy(Comparator.comparingInt(String::length))
                  .add("a", "bcd", "ef")));
}
 
Example 23
Source Project: buck   Source File: WorkerToolDescriptionTest.java    License: Apache License 2.0 5 votes vote down vote up
private static WorkerTool createWorkerTool(
    Consumer<WorkerToolDescriptionArg.Builder> setArgs,
    BiFunction<ActionGraphBuilder, BuildRule, BuildTarget> getExe) {
  TargetGraph targetGraph = TargetGraph.EMPTY;
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);

  BuildRule shBinaryRule =
      new ShBinaryBuilder(BuildTargetFactory.newInstance("//:my_exe"))
          .setMain(FakeSourcePath.of("bin/exe"))
          .build(graphBuilder);

  BuildTarget exe = getExe.apply(graphBuilder, shBinaryRule);
  Builder argsBuilder = WorkerToolDescriptionArg.builder().setName("target").setExe(exe);
  setArgs.accept(argsBuilder);

  WorkerToolDescription workerToolDescription = new WorkerToolDescription(BUCK_CONFIG);
  ProjectFilesystem projectFilesystem = new FakeProjectFilesystem();
  BuildTarget buildTarget = BuildTargetFactory.newInstance("//arbitrary:target");
  BuildRuleParams params =
      new BuildRuleParams(
          ImmutableSortedSet::of,
          () -> ImmutableSortedSet.of(graphBuilder.getRule(exe)),
          ImmutableSortedSet.of());
  return ((ProvidesWorkerTool)
          workerToolDescription.createBuildRule(
              TestBuildRuleCreationContextFactory.create(
                  targetGraph, graphBuilder, projectFilesystem),
              buildTarget,
              params,
              argsBuilder.build()))
      .getWorkerTool();
}
 
Example 24
Source Project: buck   Source File: JarDirectoryStepTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void jarsShouldContainDirectoryEntries() throws IOException {
  Path zipup = folder.newFolder("dir-zip");

  Path subdir = zipup.resolve("dir/subdir");
  Files.createDirectories(subdir);
  Files.write(subdir.resolve("a.txt"), "cake".getBytes());

  JarDirectoryStep step =
      new JarDirectoryStep(
          TestProjectFilesystems.createProjectFilesystem(zipup),
          JarParameters.builder()
              .setJarPath(Paths.get("output.jar"))
              .setEntriesToJar(ImmutableSortedSet.of(zipup))
              .setMergeManifests(true)
              .build());
  ExecutionContext context = TestExecutionContext.newInstance();

  int returnCode = step.execute(context).getExitCode();

  assertEquals(0, returnCode);

  Path zip = zipup.resolve("output.jar");
  assertTrue(Files.exists(zip));

  // Iterate over each of the entries, expecting to see the directory names as entries.
  Set<String> expected = Sets.newHashSet("dir/", "dir/subdir/");
  try (ZipInputStream is = new ZipInputStream(Files.newInputStream(zip))) {
    for (ZipEntry entry = is.getNextEntry(); entry != null; entry = is.getNextEntry()) {
      expected.remove(entry.getName());
    }
  }
  assertTrue("Didn't see entries for: " + expected, expected.isEmpty());
}
 
Example 25
Source Project: buck   Source File: ArchiveTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testThatBuildTargetSourcePathDepsAndPathsArePropagated() {
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder();
  BuildTarget target = BuildTargetFactory.newInstance("//foo:bar");
  ProjectFilesystem projectFilesystem = new FakeProjectFilesystem();

  // Create a couple of genrules to generate inputs for an archive rule.
  Genrule genrule1 =
      GenruleBuilder.newGenruleBuilder(BuildTargetFactory.newInstance("//:genrule"))
          .setOut("foo/bar.o")
          .build(graphBuilder);
  Genrule genrule2 =
      GenruleBuilder.newGenruleBuilder(BuildTargetFactory.newInstance("//:genrule2"))
          .setOut("foo/test.o")
          .build(graphBuilder);

  // Build the archive using a normal input the outputs of the genrules above.
  Archive archive =
      new Archive(
          target,
          projectFilesystem,
          graphBuilder,
          DEFAULT_ARCHIVER,
          ImmutableList.of(),
          DEFAULT_RANLIB,
          ImmutableList.of(),
          ArchiveContents.NORMAL,
          DEFAULT_OUTPUT_FILE_NAME,
          ImmutableList.of(
              FakeSourcePath.of("simple.o"),
              genrule1.getSourcePathToOutput(),
              genrule2.getSourcePathToOutput()),
          /* cacheable */ true);

  // Verify that the archive dependencies include the genrules providing the
  // SourcePath inputs.
  assertEquals(ImmutableSortedSet.<BuildRule>of(genrule1, genrule2), archive.getBuildDeps());
}
 
Example 26
Source Project: activitystreams   Source File: BoundingBox.java    License: Apache License 2.0 5 votes vote down vote up
private static void addValues(
  ImmutableSortedSet.Builder<Float> xset,
  ImmutableSortedSet.Builder<Float> yset,
  ImmutableSortedSet.Builder<Float> zset,
  Iterable<Position> positions) {
  for (Position position : positions) {
    xset.add(position.northing());
    yset.add(position.easting());
    if (position.hasAltitude())
      zset.add(position.altitude());
  }
}
 
Example 27
Source Project: buck   Source File: PythonLibraryDescriptionTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void platformSrcs() {
  ProjectFilesystem filesystem = new FakeProjectFilesystem();
  BuildTarget target = BuildTargetFactory.newInstance("//foo:lib");
  SourcePath pyPlatformMatchedSource = FakeSourcePath.of("foo/a.py");
  SourcePath cxxPlatformMatchedSource = FakeSourcePath.of("foo/b.py");
  SourcePath unmatchedSource = FakeSourcePath.of("foo/c.py");
  PythonLibraryBuilder builder =
      new PythonLibraryBuilder(target)
          .setPlatformSrcs(
              PatternMatchedCollection.<SourceSortedSet>builder()
                  .add(
                      Pattern.compile("^" + PythonTestUtils.PYTHON_PLATFORM.getFlavor() + "$"),
                      SourceSortedSet.ofUnnamedSources(
                          ImmutableSortedSet.of(pyPlatformMatchedSource)))
                  .add(
                      Pattern.compile("^" + CxxPlatformUtils.DEFAULT_PLATFORM_FLAVOR + "$"),
                      SourceSortedSet.ofUnnamedSources(
                          ImmutableSortedSet.of(cxxPlatformMatchedSource)))
                  .add(
                      Pattern.compile("won't match anything"),
                      SourceSortedSet.ofUnnamedSources(ImmutableSortedSet.of(unmatchedSource)))
                  .build());
  TargetGraph targetGraph = TargetGraphFactory.newInstance(builder.build());
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);
  PythonLibrary library = builder.build(graphBuilder, filesystem, targetGraph);
  assertThat(
      library
          .getPythonModules(
              PythonTestUtils.PYTHON_PLATFORM, CxxPlatformUtils.DEFAULT_PLATFORM, graphBuilder)
          .map(modules -> modules.getComponents().values())
          .orElseGet(ImmutableSet::of),
      Matchers.contains(pyPlatformMatchedSource, cxxPlatformMatchedSource));
}
 
Example 28
Source Project: batfish   Source File: Utils.java    License: Apache License 2.0 5 votes vote down vote up
/** Creates a generated reference book with the public IPs of the network interfaces */
static void createPublicIpsRefBook(
    Collection<NetworkInterface> networkInterfaces, Configuration cfgNode) {
  String publicIpBookName =
      GeneratedRefBookUtils.getName(cfgNode.getHostname(), BookType.PublicIps);
  checkArgument(
      !cfgNode.getGeneratedReferenceBooks().containsKey(publicIpBookName),
      "Generated reference book for public IPs already exists for node %s",
      cfgNode.getHostname());
  List<AddressGroup> publicIpAddressGroups =
      networkInterfaces.stream()
          .map(
              iface ->
                  new AddressGroup(
                      iface.getPrivateIpAddresses().stream()
                          .filter(privIp -> privIp.getPublicIp() != null)
                          .map(privIp -> privIp.getPublicIp().toString())
                          .collect(ImmutableSortedSet.toImmutableSortedSet(naturalOrder())),
                      publicIpAddressGroupName(iface)))
          .filter(ag -> !ag.getAddresses().isEmpty())
          .collect(ImmutableList.toImmutableList());
  if (!publicIpAddressGroups.isEmpty()) {
    cfgNode
        .getGeneratedReferenceBooks()
        .put(
            publicIpBookName,
            ReferenceBook.builder(publicIpBookName)
                .setAddressGroups(publicIpAddressGroups)
                .build());
  }
}
 
Example 29
Source Project: buck   Source File: IjProjectWriter.java    License: Apache License 2.0 5 votes vote down vote up
/** Update the modules.xml file with any new modules from the given set */
private void updateModulesIndex(ImmutableSet<IjModule> modulesEdited) throws IOException {
  final Set<ModuleIndexEntry> existingModules =
      modulesParser.getAllModules(
          projectFilesystem.newFileInputStream(getIdeaConfigDir().resolve("modules.xml")));
  final Set<Path> existingModuleFilepaths =
      existingModules.stream()
          .map(ModuleIndexEntry::getFilePath)
          .map(PathFormatter::pathWithUnixSeparators)
          .map(Paths::get)
          .collect(ImmutableSet.toImmutableSet());
  ImmutableSet<Path> remainingModuleFilepaths =
      modulesEdited.stream()
          .map(projectPaths::getModuleImlFilePath)
          .map(PathFormatter::pathWithUnixSeparators)
          .map(Paths::get)
          .filter(modulePath -> !existingModuleFilepaths.contains(modulePath))
          .collect(ImmutableSet.toImmutableSet());

  // Merge the existing and new modules into a single sorted set
  ImmutableSortedSet.Builder<ModuleIndexEntry> finalModulesBuilder =
      ImmutableSortedSet.orderedBy(Comparator.<ModuleIndexEntry>naturalOrder());
  // Add the existing definitions
  finalModulesBuilder.addAll(existingModules);
  // Add any new module definitions that we haven't seen yet
  remainingModuleFilepaths.forEach(
      modulePath ->
          finalModulesBuilder.add(
              ModuleIndexEntry.of(
                  getUrl(projectPaths.getProjectQualifiedPath(modulePath)),
                  projectPaths.getProjectRelativePath(modulePath),
                  projectConfig.getModuleGroupName())));

  // Write out the merged set to disk
  writeModulesIndex(finalModulesBuilder.build());
}
 
Example 30
Source Project: buck   Source File: CxxLibraryDescriptionTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void sharedLibraryShouldLinkOwnRequiredLibraries() {
  ProjectFilesystem filesystem = new FakeProjectFilesystem();
  CxxPlatform platform = CxxPlatformUtils.DEFAULT_PLATFORM;

  CxxLibraryBuilder libraryBuilder =
      new CxxLibraryBuilder(
          BuildTargetFactory.newInstance("//:foo")
              .withFlavors(platform.getFlavor(), CxxDescriptionEnhancer.SHARED_FLAVOR));
  libraryBuilder
      .setLibraries(
          ImmutableSortedSet.of(
              FrameworkPath.ofSourceTreePath(
                  new SourceTreePath(
                      PBXReference.SourceTree.SDKROOT,
                      Paths.get("/usr/lib/libz.dylib"),
                      Optional.empty())),
              FrameworkPath.ofSourcePath(FakeSourcePath.of("another/path/liba.dylib"))))
      .setSrcs(ImmutableSortedSet.of(SourceWithFlags.of(FakeSourcePath.of("foo.c"))));
  TargetGraph targetGraph = TargetGraphFactory.newInstance(libraryBuilder.build());
  ActionGraphBuilder graphBuilder = new TestActionGraphBuilder(targetGraph);
  CxxLink library = (CxxLink) libraryBuilder.build(graphBuilder, filesystem, targetGraph);
  assertThat(
      Arg.stringify(library.getArgs(), graphBuilder.getSourcePathResolver()),
      hasItems("$SDKROOT/usr/lib", "-la", "-lz"));
  assertThat(
      Arg.stringify(library.getArgs(), graphBuilder.getSourcePathResolver()), hasItems("-L"));
  assertThat(
      Arg.stringify(library.getArgs(), graphBuilder.getSourcePathResolver()),
      hasItems(matchesPattern(".*another[/\\\\]path$")));
}