com.google.common.collect.Maps Java Examples

private void notifyDataStepDataGenerated() {
  if (EventManager.isHandled(CoreEventTypes.DATA_STEP_DATA_GENERATED)) {
    long startTime = System.nanoTime();

    if (!isCached()) {
      cache();
    }

    long count = data.count();
    long timeTakenNs = System.nanoTime() - startTime;
    String prettyTimeTaken = EventUtils.prettifyNs(timeTakenNs);

    Map<String, Object> metadata = Maps.newHashMap();
    metadata.put(CoreEventMetadataKeys.DATA_STEP_DATA_GENERATED_STEP_NAME, getName());
    metadata.put(CoreEventMetadataKeys.DATA_STEP_DATA_GENERATED_ROW_COUNT, count);
    metadata.put(CoreEventMetadataKeys.DATA_STEP_DATA_GENERATED_TIME_TAKEN_NS, timeTakenNs);

    String message = "Data step " + getName() + " generated " + count + " rows in " + prettyTimeTaken;

    EventManager.notify(new Event(CoreEventTypes.DATA_STEP_DATA_GENERATED, message, metadata));
  }
}
 

@Before
public void setUp() throws CloudbreakException, JsonProcessingException, CloudbreakOrchestratorFailedException {
    MockitoAnnotations.initMocks(this);
    when(gatewayConfigService.getGatewayConfig(any(Stack.class), any(InstanceMetaData.class), anyBoolean())).thenReturn(gatewayConfig);

    InstanceMetadataUpdater.Package packageByName = new InstanceMetadataUpdater.Package();
    packageByName.setName("packageByName");
    packageByName.setPkg(Lists.newArrayList(generatePackageName("packageByName", "(.*)-(.*)")));
    InstanceMetadataUpdater.Package packageByCmd = new InstanceMetadataUpdater.Package();
    packageByCmd.setName("packageByCmd");
    packageByCmd.setPkg(Lists.newArrayList(generatePackageName("packageByCmd", null)));

    underTest.setPackages(Lists.newArrayList(packageByCmd, packageByName));

    Map<String, Map<String, String>> hostPackageMap = Maps.newHashMap();
    hostPackageMap.put("instanceId", packageMap());
    hostPackageMap.put("hostByCmd", packageMap());
    when(hostOrchestrator.getPackageVersionsFromAllHosts(any(GatewayConfig.class), any())).thenReturn(hostPackageMap);
}
 

@Test
public void assertWithDataSource() throws Exception {
    File yamlFile = new File(YamlOrchestrationMasterSlaveIntegrateTest.class.getResource(filePath).toURI());
    DataSource dataSource;
    if (hasDataSource) {
        dataSource = YamlOrchestrationShardingSphereDataSourceFactory.createDataSource(yamlFile);
    } else {
        dataSource = YamlOrchestrationShardingSphereDataSourceFactory.createDataSource(
                Maps.asMap(Sets.newHashSet("db_master", "db_slave_0", "db_slave_1"), AbstractYamlDataSourceTest::createDataSource), yamlFile);
    }
    try (Connection connection = dataSource.getConnection();
         Statement statement = connection.createStatement()) {
        statement.executeQuery("SELECT * FROM t_order");
        statement.executeQuery("SELECT * FROM t_order_item");
        statement.executeQuery("SELECT * FROM t_config");
    }
    ((OrchestrationShardingSphereDataSource) dataSource).close();
}
 

@Test
public void testMultipleValuesCanBeSeparatedByComaTo() {
    Map<String, String> parameters = Maps.newHashMap();

    String paramName = "zeParam";
    String paramValue1 = "un";
    String paramValue2 = "deux";
    String paramValue3 = "trois";

    parameters.put(paramName, paramValue1 + "," + paramValue2 + "," + paramValue3);

    String[] values = MacroParametersUtils.extractParameterMultiple(paramName, parameters);
    assertEquals(3, values.length);
    assertEquals(paramValue1, values[0]);
    assertEquals(paramValue2, values[1]);
    assertEquals(paramValue3, values[2]);
}
 

@NotNull
public static FormStatusModel buildModelFromCsv(@NotNull final String pathToCsv) throws IOException {
    Map<FormStatusKey, FormStatus> formStatuses = Maps.newHashMap();
    List<String> lines = FileReader.build().readLines(new File(pathToCsv).toPath());
    // No need to read the header line
    lines.remove(0);
    for (String line : lines) {
        String[] parts = splitCsvLine(line, FIELD_SEPARATOR, FIELD_COUNT);
        if (parts.length == FIELD_COUNT) {
            FormStatusKey formKey = new ImmutableFormStatusKey(removeQuotes(parts[PATIENT_ID_COLUMN].replaceAll("-", "")),
                    removeParentheses(removeQuotes(parts[FORM_NAME_COLUMN])),
                    removeQuotes(parts[FORM_SEQ_NUM_COLUMN]),
                    removeParentheses(removeQuotes(parts[STUDY_EVENT_NAME_COLUMN])),
                    removeQuotes(parts[STUDY_EVENT_SEQ_NUM_COLUMN]));
            FormStatus formStatus = new ImmutableFormStatus(interpretState(removeQuotes(parts[DATA_STATUS_COLUMN])),
                    interpretLocked(removeQuotes(parts[LOCKED_COLUMN])));
            formStatuses.put(formKey, formStatus);
        } else if (parts.length > 0) {
            LOGGER.warn("Could not properly parse line in form status csv: {}", line);
        }
    }
    return new ImmutableFormStatusModel(formStatuses);
}
 

@Override
public SortedMap<Integer, String> tokenListWithPos(final char[] code) {
	final SortedMap<Integer, String> tokens = Maps.newTreeMap();
	tokens.put(-1, SENTENCE_START);
	tokens.put(Integer.MAX_VALUE, SENTENCE_END);

	final Scanner scanner = new Scanner();
	scanner.setSource(code);
	final WhitespaceToTokenConverter wsConverter = new WhitespaceToTokenConverter();
	do {
		final int token = scanner.getNextToken();
		if (token == Token.tWHITESPACE) {
			final String wsToken = wsConverter
					.toWhiteSpaceSymbol(new String(scanner
							.getCurrentTokenSource()));
			tokens.put(scanner.getCurrentPosition(), wsToken);
		} else {
			final String nxtToken = new String(
					scanner.getCurrentTokenSource());
			tokens.put(scanner.getCurrentPosition(),
					getTokenType(token, nxtToken));
		}
	} while (!scanner.atEnd());
	return tokens;
}
 

public void resumeJob(String jobId) {
    AbstractExecutable job = getJob(jobId);
    if (job == null) {
        return;
    }
    Map<String, String> info = null;
    if (job instanceof DefaultChainedExecutable) {
        List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks();
        for (AbstractExecutable task : tasks) {
            if (task.getStatus() == ExecutableState.ERROR || task.getStatus() == ExecutableState.STOPPED) {
                updateJobOutput(task.getId(), ExecutableState.READY, null, "no output");
                break;
            }
        }
        final long endTime = job.getEndTime();
        if (endTime != 0) {
            long interruptTime = System.currentTimeMillis() - endTime + job.getInterruptTime();
            info = Maps.newHashMap(getJobOutput(jobId).getInfo());
            info.put(AbstractExecutable.INTERRUPT_TIME, Long.toString(interruptTime));
            info.remove(AbstractExecutable.END_TIME);
        }
    }
    updateJobOutput(jobId, ExecutableState.READY, info, null);
}
 

@BeforeClass
public static synchronized void doSetup() throws Exception {
    Map<String, String> props = Maps.newHashMapWithExpectedSize(11);
    // Set a very small cache size to force plenty of spilling
    props.put(QueryServices.GROUPBY_MAX_CACHE_SIZE_ATTRIB,
            Integer.toString(1));
    props.put(QueryServices.GROUPBY_SPILLABLE_ATTRIB, String.valueOf(true));
    props.put(QueryServices.GROUPBY_SPILL_FILES_ATTRIB,
            Integer.toString(1));
    // Large enough to not run out of memory, but small enough to spill
    props.put(QueryServices.MAX_MEMORY_SIZE_ATTRIB, Integer.toString(40000));
    
    // Set guidepost width, but disable stats
    props.put(QueryServices.STATS_GUIDEPOST_WIDTH_BYTES_ATTRIB, Long.toString(20));
    props.put(QueryServices.STATS_COLLECTION_ENABLED, Boolean.toString(false));
    props.put(QueryServices.EXPLAIN_CHUNK_COUNT_ATTRIB, Boolean.TRUE.toString());
    props.put(QueryServices.EXPLAIN_ROW_COUNT_ATTRIB, Boolean.TRUE.toString());
    // Must update config before starting server
    setUpTestDriver(new ReadOnlyProps(props.entrySet().iterator()));
}
 

/**
 * List by parentId, return json format string
 *
 * @throws IOException
 */
@RequestMapping("/ajax-list/{parentId}")
public void ajaxList(@PathVariable String parentId, HttpServletResponse response) throws IOException {
	List<Area> areaList = areaService.findByParentId(parentId);

	// @todo
	List<Map<String, Object>> list = Lists.newArrayList();
	for (Area area : areaList) {
		Map<String, Object> map = Maps.newHashMap();
		map.put("id", area.getId());
		map.put("parentId", area.getParentId());
		map.put("name", area.getName());
		list.add(map);
	}

	boolean res = true;
	String msg = "区域列表";

	JsonUtils.setResponse(response);
	response.getWriter().print(JsonUtils.toString(res, msg, list));
}
 

private static List<LibraryDependencyImpl> convertLibraryInfoIntoDependency(
        @NonNull List<LibInfo> libInfos,
        @NonNull Multimap<LibraryDependency, VariantDependencies> reverseMap) {
    List<LibraryDependencyImpl> list = Lists.newArrayListWithCapacity(libInfos.size());

    // since the LibInfos is a graph and the previous "foundLibraries" map ensure we reuse
    // instance where applicable, we'll create a map to keep track of what we have already
    // converted.
    Map<LibInfo, LibraryDependencyImpl> convertedMap = Maps.newIdentityHashMap();

    for (LibInfo libInfo : libInfos) {
        list.add(convertLibInfo(libInfo, reverseMap, convertedMap));
    }

    return list;
}
 

public final void testEnvironmentData() throws Exception {
  Scriptable s = (Scriptable) RhinoTestBed.runJs(
      new RhinoExecutor.Input(  // TODO: make an ASCII-art Rhino.
          "var navigator = { userAgent: 'Rhino Rhino Rhino' };", "rhino-env"),
      new RhinoExecutor.Input(getClass(), "environment-checks.js"),
      new RhinoExecutor.Input("env", getName())
      );
  Map<String, Object> env = Maps.newHashMap();
  for (Object key : ScriptableObject.getPropertyIds(s)) {
    String code = "" + key;
    env.put(EnvironmentData.normJs(code, mq), s.get(code, s));
  }
  for (EnvironmentDatum datum : EnvironmentDatum.values()) {
    assertTrue(datum.name(), env.containsKey(datum.getCode()));
    System.err.println(datum + " = " + env.get(datum.getCode()));
  }
  assertEquals(
      "Rhino Rhino Rhino",
      env.get(EnvironmentDatum.NAV_USER_AGENT.getCode()));
}
 

@Override
public Map<SkyKey, Pair<SkyValue, Iterable<SkyKey>>> getValueAndRdeps(Iterable<SkyKey> keys)
    throws InterruptedException {
  Map<SkyKey, ? extends NodeEntry> entries =
      getBatch(null, Reason.WALKABLE_GRAPH_VALUE_AND_RDEPS, keys);
  Map<SkyKey, Pair<SkyValue, Iterable<SkyKey>>> result =
      Maps.newHashMapWithExpectedSize(entries.size());
  for (Map.Entry<SkyKey, ? extends NodeEntry> entry : entries.entrySet()) {
    // See comment in #getReverseDeps.
    if (entry.getValue().isDone()) {
      result.put(
          entry.getKey(),
          Pair.of(
              getValueFromNodeEntry(entry.getValue()),
              entry.getValue().getReverseDepsForDoneEntry()));
    }
  }
  return result;
}
 

@RequestMapping(value = "/getDemoData")
@ResponseBody
public Object getColInfoByTabname() {

    Map<String, Object> map = Maps.newHashMap();
    List<Map<String,String>> demoDatas = Lists.newArrayList();
    Map<String,String> col1 = Maps.newHashMap();
    col1.put("demo_type","string");
    col1.put("demo_flag","1");
    col1.put("demo_remark","stirng 类型");
    demoDatas.add(col1);

    Map<String,String> col2 = Maps.newHashMap();
    col2.put("demo_type","long");
    col2.put("demo_flag","1");
    col2.put("demo_remark","long 类型");
    demoDatas.add(col2);

    Map<String,String> col3 = Maps.newHashMap();
    col3.put("demo_type","date");
    col3.put("demo_flag","1");
    col3.put("demo_remark","date 类型");
    demoDatas.add(col3);
    map.put("result", demoDatas);
    return map;
}
 

private static Map<String, Object> getSshFlags(Location location) {
    Set<ConfigKey<?>> sshConfig = MutableSet.of();
    
    StringConfigMap mgmtConfig = null;
    sshConfig.addAll(location.config().findKeysPresent(ConfigPredicates.nameStartsWith(SshTool.BROOKLYN_CONFIG_KEY_PREFIX)));
    if (location instanceof AbstractLocation) {
        ManagementContext mgmt = ((AbstractLocation)location).getManagementContext();
        if (mgmt!=null) {
            mgmtConfig = mgmt.getConfig();
            sshConfig.addAll(mgmtConfig.findKeysPresent(ConfigPredicates.nameStartsWith(SshTool.BROOKLYN_CONFIG_KEY_PREFIX)));
        }
    }
    
    
    Map<String, Object> result = Maps.newLinkedHashMap();
    for (ConfigKey<?> key : sshConfig) {
        Maybe<Object> v = ((LocationInternal)location).config().getRaw(key);
        if (v.isAbsent() && mgmtConfig!=null) v = Maybe.of( (Object) mgmtConfig.getConfig(key) );
        result.put(ConfigUtils.unprefixedKey(SshTool.BROOKLYN_CONFIG_KEY_PREFIX, key).getName(), v.get());
    }
    return result;
}
 

@Test
public void asDataPointsShouldReturnCorrectDataPoints() {

    List<DataPoint<HeartRate>> dataPoints = mapper.asDataPoints(singletonList(responseNode));

    HeartRate expectedHeartRate = new HeartRate.Builder(55)
            .setTemporalRelationshipToPhysicalActivity(AT_REST)
            .setEffectiveTimeFrame(OffsetDateTime.parse("2013-11-20T08:05:00-08:00"))
            .build();

    assertThat(dataPoints.get(0).getBody(), equalTo(expectedHeartRate));

    // TODO kill maps
    Map<String, Object> testProperties = Maps.newHashMap();
    testProperties.put(HEADER_EXTERNAL_ID_KEY, "40F7_htRRnT8Vo7nRBZO1X");
    testProperties.put(HEADER_SOURCE_UPDATE_KEY, "2013-11-21T15:59:59Z");
    testProperties.put(HEADER_SCHEMA_ID_KEY, HeartRate.SCHEMA_ID);
    testProperties.put(HEADER_SENSED_KEY, DataPointModality.SENSED);
    testDataPointHeader(dataPoints.get(0).getHeader(), testProperties);
}
 

@Override
public SortedMap<Integer, FullToken> fullTokenListWithPos(final char[] code) {
	final SortedMap<Integer, FullToken> tokens = Maps.newTreeMap();
	tokens.put(-1, new FullToken(SENTENCE_START, SENTENCE_START));
	tokens.put(Integer.MAX_VALUE, new FullToken(SENTENCE_END, SENTENCE_END));

	final Scanner scanner = new Scanner();
	scanner.setSource(code);
	final WhitespaceToTokenConverter wsConverter = new WhitespaceToTokenConverter();
	do {
		final int token = scanner.getNextToken();
		if (token == Token.tWHITESPACE) {
			final String wsToken = wsConverter
					.toWhiteSpaceSymbol(new String(scanner
							.getCurrentTokenSource()));
			tokens.put(scanner.getCurrentPosition(), new FullToken(wsToken,
					Integer.toString(token)));
		} else {
			final String nxtToken = new String(
					scanner.getCurrentTokenSource());
			tokens.put(scanner.getCurrentPosition(), new FullToken(
					getTokenType(token, nxtToken), Integer.toString(token)));
		}
	} while (!scanner.atEnd());
	return tokens;
}
 

@Test
public void testDeterministicNesting() throws JsonProcessingException
{
    @SuppressWarnings("unused")
    Object obj = new Object() {
        public String get1() { return "1"; }
        public String getC() { return "C"; }
        public String getA() { return "A"; }
    };

    Set<Integer> ints = Sets.newLinkedHashSet(Lists.newArrayList(1, 4, 2, 3, 5, 7, 8, 9, 6, 0, 50, 100, 99));

    Map<String, Object> data = Maps.newLinkedHashMap();
    data.put("obj", obj);
    data.put("c", "C");
    data.put("ints", ints);

    String actual = mapper.writer().writeValueAsString(data);
    String expected = "{" +
                        "\"c\":\"C\"," +
                        "\"ints\":[0,1,2,3,4,5,6,7,8,9,50,99,100]," +
                        "\"obj\":{\"1\":\"1\",\"a\":\"A\",\"c\":\"C\"}" +
                      "}";
    assertEquals(expected, actual);
}
 

/**
 * Builds the query.
 *
 * @param filter the filter
 * @return elastic search query details
 */
static Map<String, Object> buildQuery(final Map<String, String> filter) {
	Map<String, Object> queryFilters = Maps.newHashMap();
	Map<String, Object> boolFilters = Maps.newHashMap();
	List<Map<String, Object>> should = Lists.newArrayList();
	for (Map.Entry<String, String> entry : filter.entrySet()) {
		Map<String, Object> term = Maps.newHashMap();
		Map<String, Object> termDetails = Maps.newHashMap();
		termDetails.put(entry.getKey(), entry.getValue());
		term.put("term", termDetails);
		should.add(term);
	}
	boolFilters.put("should", should);
	queryFilters.put("bool", boolFilters);
	return queryFilters;
}
 

public void doTestFileFormatV2PreFLUME1432(boolean useLogReplayV1)
        throws Exception {
  TestUtils.copyDecompressed("fileformat-v2-pre-FLUME-1432-checkpoint.gz",
          new File(checkpointDir, "checkpoint"));
  for (int i = 0; i < dataDirs.length; i++) {
    int fileIndex = i + 1;
    TestUtils.copyDecompressed("fileformat-v2-pre-FLUME-1432-log-" + fileIndex
        + ".gz", new File(dataDirs[i], "log-" + fileIndex));
  }
  Map<String, String> overrides = Maps.newHashMap();
  overrides.put(FileChannelConfiguration.CAPACITY, String.valueOf(10000));
  overrides.put(FileChannelConfiguration.USE_LOG_REPLAY_V1,
          String.valueOf(useLogReplayV1));
  channel = createFileChannel(overrides);
  channel.start();
  Assert.assertTrue(channel.isOpen());
  Set<String> events = takeEvents(channel, 1);
  Assert.assertEquals(50, events.size());
}
 

/**
 * 关于我们
 */
@RequestMapping("/us")
public String list(HttpServletResponse response) {
       boolean result;
       String message;
       Map<String, Object> data = Maps.newHashMap();
       Map<String, Object> us = Maps.newHashMap();

       String desc = "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;月光茶人为客户提供休闲温馨的环境，以最真诚的态度服务于我们的客户，提供香浓的咖啡、健康的奶茶和美味的小吃。为了让客户享受更便捷的服务和优惠价格，我们开发了月光茶人APP，欢迎使用。";
       String copyright = "Copyright © 2015";
       String company = "深圳市宝安区福永月光茶人饮品店";
       String address = "深圳市宝安区福永东福围东街103-5";
       String tel = "联系电话：0755-29350032";
       us.put("desc", desc);
       us.put("copyright", copyright);
       us.put("company", company);
       us.put("address", address);
       us.put("tel", tel);

       result = true;
       message = "";
       data.put("us", us);
       return renderString(response, result, message, data);
}
 

private static JobDiff computeUnscoped(
    Map<Integer, ITaskConfig> currentState,
    IJobKey job,
    Map<Integer, ITaskConfig> proposedState) {

  requireNonNull(job);
  requireNonNull(proposedState);

  MapDifference<Integer, ITaskConfig> diff = Maps.difference(currentState, proposedState);

  Map<Integer, ITaskConfig> removedInstances = ImmutableMap.<Integer, ITaskConfig>builder()
      .putAll(diff.entriesOnlyOnLeft())
      .putAll(Maps.transformValues(diff.entriesDiffering(), JobDiff.leftValue()))
      .build();

  Set<Integer> addedInstances = ImmutableSet.<Integer>builder()
      .addAll(diff.entriesOnlyOnRight().keySet())
      .addAll(diff.entriesDiffering().keySet())
      .build();

  return new JobDiff(
      removedInstances,
      addedInstances,
      ImmutableMap.copyOf(diff.entriesInCommon()));
}
 

@Before
public void setup() {
  downloadEmailUtils = mock(DownloadEmailUtils.class);
  occurrenceDownloadService = mock(OccurrenceDownloadService.class);
  downloadLimitsService= mock(DownloadLimitsService.class);
  when(downloadLimitsService.exceedsSimultaneousDownloadLimit(any(String.class))).thenReturn(null);
  when(downloadLimitsService.exceedsDownloadComplexity(any(DownloadRequest.class))).thenReturn(null);
  when(occurrenceDownloadService.get(anyString())).thenReturn(mockDownload());
  oozieClient = mock(OozieClient.class);
  service =
    new DownloadRequestServiceImpl(oozieClient, Maps.<String, String>newHashMap(), "http://localhost:8080/",
      "", occurrenceDownloadService, downloadEmailUtils,downloadLimitsService);
}
 

private HttpURLConnection doVersionRequest(String version) throws IOException {
  final Map<String, List<String>> headers = Maps.newHashMap();
  headers.put("Content-Type", asList("application/json"));
  headers.put("Charset", asList("utf-8"));
  if (version != null) {
    headers.put(HELIOS_VERSION_HEADER, asList(version));
  }
  final URI uri = URI.create(masterEndpoint() + "/version");
  final HttpURLConnection connection = connect(uri, headers);
  return connection;
}
 

protected FetchTopicMessageRequest buildFetchTopicMessageCommand(List<String> topics, String app, int count, long ackTimeout, long longPollTimeout) {
    Map<String, FetchTopicMessageData> topicMap = Maps.newHashMap();
    for (String topic : topics) {
        topicMap.put(topic, new FetchTopicMessageData(count));
    }

    FetchTopicMessageRequest fetchTopicMessageRequest = new FetchTopicMessageRequest();
    fetchTopicMessageRequest.setTopics(topicMap);
    fetchTopicMessageRequest.setApp(app);
    fetchTopicMessageRequest.setAckTimeout((int) ackTimeout);
    fetchTopicMessageRequest.setLongPollTimeout((int) longPollTimeout);
    return fetchTopicMessageRequest;
}
 

private Map<String, Integer> buildSelectedTargetTypesIndex(List<AssetGroupTargetTypes> selectedTargetTypes) {
	Map<String, Integer> selectedTargetTypeIndex = Maps.newHashMap();
	for (int index = 0; index < selectedTargetTypes.size(); index++) {
		selectedTargetTypeIndex.put(selectedTargetTypes.get(index).getTargetType().toLowerCase(), index);
	}
	return selectedTargetTypeIndex;
}
 

public static Map<String, Object> toMap(JSONObject jsonObject) {
	Map<String, Object> data = Maps.newHashMap();
	// 将json字符串转换成jsonObject
	Iterator<String> it = jsonObject.keySet().iterator();
	// 遍历jsonObject数据，添加到Map对象
	while (it.hasNext()) {
		String key = String.valueOf(it.next());
		Object value = jsonObject.get(key);
		data.put(key, value);
	}
	return data;
}
 

public static <T> Map<String, Object> convertBeanToMap(T bean) {
    Map<String, Object> map = Maps.newHashMap();
    if (bean != null) {
        BeanMap beanMap = BeanMap.create(bean);
        for (Object key : beanMap.keySet()) {
            if (beanMap.get(key) != null) {
                map.put(key.toString(), beanMap.get(key));
            }
        }
    }
    return map;
}
 

public JCloudsPropertiesBuilder setCustomJcloudsProperties() {
    Map<String, Object> extra = Maps.filterKeys(conf.getAllConfig(), Predicates.containsPattern("^jclouds\\."));
    if (extra.size() > 0) {
        String provider = getProviderFromConfig(conf);
        LOG.debug("Configuring custom jclouds property overrides for {}: {}", provider, Sanitizer.sanitize(extra));
    }
    properties.putAll(Maps.filterValues(extra, Predicates.notNull()));
    return this;
}
 

/**
 * Tests device metrics map update and query.
 */
@Test
public void testDeviceMetricsMap() {
    ControlResource.Type type = ControlResource.Type.CONTROL_MESSAGE;
    DeviceId devId1 = DeviceId.deviceId("of:0000000000000101");
    DeviceId devId2 = DeviceId.deviceId("of:0000000000000102");

    devMetricsMap = Maps.newHashMap();

    Set<DeviceId> devices = ImmutableSet.of(devId1, devId2);
    devices.forEach(dev -> {
        if (!devMetricsMap.containsKey(dev)) {
            devMetricsMap.put(dev, genMDbBuilder(type, ControlResource.CONTROL_MESSAGE_METRICS)
                    .withResourceName(dev.toString())
                    .build());
        }
    });

    Map<String, Double> metrics1 = new HashMap<>();
    ControlResource.CONTROL_MESSAGE_METRICS.forEach(msgType ->
            metrics1.putIfAbsent(msgType.toString(), 10D));

    Map<String, Double> metrics2 = new HashMap<>();
    ControlResource.CONTROL_MESSAGE_METRICS.forEach(msgType ->
            metrics2.putIfAbsent(msgType.toString(), 20D));


    devMetricsMap.get(devId1).updateMetrics(metrics1);
    devMetricsMap.get(devId2).updateMetrics(metrics2);

    ControlResource.CONTROL_MESSAGE_METRICS.forEach(msgType ->
            assertThat(10D, is(devMetricsMap.get(devId1).recentMetric(msgType.toString())))
    );

    ControlResource.CONTROL_MESSAGE_METRICS.forEach(msgType ->
            assertThat(20D, is(devMetricsMap.get(devId2).recentMetric(msgType.toString())))
    );
}
 

void defineDataSource(Location loc, String name, boolean hasAliasDefinition) {
    if (isCursor(name)) {
        throw new ProgramCompileException(loc, "Alias '%s' is already used.", name);
    }
    if (cursors.isEmpty()) {
        cursors = Maps.newHashMap();
    }
    cursors.put(name, Boolean.valueOf(hasAliasDefinition));
}