Java 类java.util.AbstractMap.SimpleEntry 实例源码

public static void main(String[] args) throws Exception {
    List<Entry> actualEntries = findEntries();
    List<Entry> expectedEntries = List.of(
            new SimpleEntry<>(29, 0),
            new SimpleEntry<>(30, 4),
            new SimpleEntry<>(32, 9),
            new SimpleEntry<>(33, 16),
            new SimpleEntry<>(34, 32),
            new SimpleEntry<>(35, 46),
            new SimpleEntry<>(36, 52)
    );
    if (!Objects.equals(actualEntries, expectedEntries)) {
        error(String.format("Unexpected LineNumberTable: %s", actualEntries.toString()));
    }

    try {
        new Test();
    } catch (NullPointerException npe) {
        if (Arrays.stream(npe.getStackTrace())
                  .noneMatch(se -> se.getFileName().contains("NullCheckLineNumberTest") &&
                                   se.getLineNumber() == 34)) {
            throw new AssertionError("Should go through line 34!");
        }
    }
}

/**
 * Extracts and exports normal parameters
 * 
 * @param writer Writer object
 * @param ob Object 
 * @throws XMLStreamException 
 */
static void exportParameters(XMLStreamWriter writer,
        Object ob) throws XMLStreamException {
    Method[] mets = ob.getClass().getMethods();
    for(Method m : mets) {
        //lookup if the Method is marked as ExchangeParameter and NOT a setter
        ExchangeParameter ep = m.getAnnotation(ExchangeParameter.class);
        if(ep != null && m.getName().contains("get")) {
            writer.writeEmptyElement("Parameter");
            String paramName = m.getName().substring(3);
            SimpleEntry<String, String> se = exportParamType(ob, m.getName());
            writer.writeAttribute("name", paramName);
            writer.writeAttribute("type", se.getKey());
            writer.writeAttribute("value", se.getValue());
        }
    }

}

/**
 * Extracts and write out the AdditionalConstructionParameters to the writer
 * 
 * @param writer Given Writer
 * @param ob Object with annotations from AdditionalConstructParameter.class
 * @throws XMLStreamException 
 */
static void exportConstructParameters(XMLStreamWriter writer,
        Object ob) throws XMLStreamException {
    //Get the Construction Parameters
    AdditionalConstructParameter acp = ob.getClass().getAnnotation(AdditionalConstructParameter.class);
    if(acp != null) {
        for(int i = 0; i < acp.parameterGetters().length; i++) {
            writer.writeEmptyElement("ConstructParameter");
            writer.writeAttribute("name", acp.parameterNames()[i]);
            SimpleEntry<String, String> se = exportParamType(ob, acp.parameterGetters()[i]);
            writer.writeAttribute("type", se.getKey());
            writer.writeAttribute("value", se.getValue());
        }
    }


}

public static <T> List<T> getSortedService(Class<T> serviceType) {
  List<Entry<Integer, T>> serviceEntries = new ArrayList<>();
  ServiceLoader<T> serviceLoader = ServiceLoader.load(serviceType);
  serviceLoader.forEach(service -> {
    int serviceOrder = 0;
    Method getOrder = ReflectionUtils.findMethod(service.getClass(), "getOrder");
    if (getOrder != null) {
      serviceOrder = (int) ReflectionUtils.invokeMethod(getOrder, service);
    }

    Entry<Integer, T> entry = new SimpleEntry<>(serviceOrder, service);
    serviceEntries.add(entry);
  });

  return serviceEntries.stream()
      .sorted(Comparator.comparingInt(Entry::getKey))
      .map(Entry::getValue)
      .collect(Collectors.toList());
}

public static <K, V> Entry<K, V> firstEntry(NavigableMap<K, ? extends Iterable<V>> map) {
    Entry<K, V> result = null;

    Iterator<? extends Entry<K, ? extends Iterable<V>>> itE = map.entrySet().iterator();

    // For robustness, remove entry valueX sets
    while(itE.hasNext()) {
        Entry<K, ? extends Iterable<V>> e = itE.next();

        K k = e.getKey();
        Iterable<V> vs = e.getValue();

        Iterator<V> itV = vs.iterator();
        if(itV.hasNext()) {
            V v = itV.next();

            result = new SimpleEntry<>(k, v);
            break;
        } else {
            continue;
        }
    }

    return result;
}

@Test
public void testExtraLinks() {
    final String inbox = "http://ldn.example.com/inbox";
    final String annService = "http://annotation.example.com/resource";

    when(mockResource.getExtraLinkRelations()).thenAnswer(inv -> Stream.of(
            new SimpleEntry<>(annService, OA.annotationService.getIRIString()),
            new SimpleEntry<>(SKOS.Concept.getIRIString(), "type"),
            new SimpleEntry<>(inbox, "inbox")));
    when(mockHeaders.getAcceptableMediaTypes()).thenReturn(singletonList(TEXT_TURTLE_TYPE));

    final GetHandler getHandler = new GetHandler(mockLdpRequest, mockResourceService,
            mockIoService, mockBinaryService, baseUrl);

    final Response res = getHandler.getRepresentation(mockResource).build();
    assertEquals(OK, res.getStatusInfo());
    assertTrue(res.getLinks().stream().anyMatch(hasType(SKOS.Concept)));
    assertTrue(res.getLinks().stream().anyMatch(hasLink(rdf.createIRI(inbox), "inbox")));
    assertTrue(res.getLinks().stream().anyMatch(hasLink(rdf.createIRI(annService),
                    OA.annotationService.getIRIString())));
}

public final Iterator<Map.Entry<K,V>> iterator() {
    return new MapIterator<Map.Entry<K,V>>() {
        @Override
        public Map.Entry<K,V> next() {
            if (mapEntry == null) {
                throw new NoSuchElementException();
            }

            SimpleEntry<K, V> result = new SimpleEntry<K, V>(mapEntry.getKey(), readValue(mapEntry.getValue()));
            mapEntry = null;
            return result;
        }

        @Override
        public void remove() {
            if (mapEntry == null) {
                throw new IllegalStateException();
            }
            map.remove(mapEntry.getKey(), mapEntry.getValue());
            mapEntry = null;
        }
    };
}

static List<Entry> findEntries() throws IOException, ConstantPoolException {
    ClassFile self = ClassFile.read(NullCheckLineNumberTest.Test.class.getResourceAsStream("NullCheckLineNumberTest$Test.class"));
    for (Method m : self.methods) {
        if ("<init>".equals(m.getName(self.constant_pool))) {
            Code_attribute code_attribute = (Code_attribute)m.attributes.get(Attribute.Code);
            for (Attribute at : code_attribute.attributes) {
                if (Attribute.LineNumberTable.equals(at.getName(self.constant_pool))) {
                    return Arrays.stream(((LineNumberTable_attribute)at).line_number_table)
                                 .map(e -> new SimpleEntry<> (e.line_number, e.start_pc))
                                 .collect(Collectors.toList());
                }
            }
        }
    }
    return null;
}

private <T> void sendMessageToManagerForConfiguredShards(DataStoreType dataStoreType,
        List<Entry<ListenableFuture<T>, ShardResultBuilder>> shardResultData,
        Function<String, Object> messageSupplier) {
    ActorContext actorContext = dataStoreType == DataStoreType.Config ? configDataStore.getActorContext()
            : operDataStore.getActorContext();
    Set<String> allShardNames = actorContext.getConfiguration().getAllShardNames();

    LOG.debug("Sending message to all shards {} for data store {}", allShardNames, actorContext.getDataStoreName());

    for (String shardName: allShardNames) {
        ListenableFuture<T> future = this.ask(actorContext.getShardManager(), messageSupplier.apply(shardName),
                                              SHARD_MGR_TIMEOUT);
        shardResultData.add(new SimpleEntry<>(future,
                new ShardResultBuilder().setShardName(shardName).setDataStoreType(dataStoreType)));
    }
}

private void possiblyAddConfigModuleIdentifier(final ServiceReference<?> reference,
        final List<Entry<String, ModuleIdentifier>> configModules) {
    Object moduleNamespace = reference.getProperty(CONFIG_MODULE_NAMESPACE_PROP);
    if (moduleNamespace == null) {
        return;
    }

    String moduleName = getRequiredConfigModuleProperty(CONFIG_MODULE_NAME_PROP, moduleNamespace,
            reference);
    String instanceName = getRequiredConfigModuleProperty(CONFIG_INSTANCE_NAME_PROP, moduleNamespace,
            reference);
    if (moduleName == null || instanceName == null) {
        return;
    }

    LOG.debug("Found service with config module: namespace {}, module name {}, instance {}",
            moduleNamespace, moduleName, instanceName);

    configModules.add(new SimpleEntry<>(moduleNamespace.toString(),
            new ModuleIdentifier(moduleName, instanceName)));
}

/**
 * Searches for a group of Keys and print each occurrence and its file name. 
 * @param keys
 */
private ArrayList<SimpleEntry> returnFNameLineGroup(String[] keys, boolean printName){
    ArrayList<SimpleEntry> eA = new ArrayList<>();
    ArrayList<SimpleEntry> keyRes = new ArrayList<>();

    for (String s: keys){
        keyRes = this.sU.searchForKeyInJava(s,this.codeRoot);
        if (printName && (!keyRes.isEmpty()))
            OutBut.printH3(s);

        eA.addAll(this.sU.searchForKeyInJava(s,this.codeRoot));
    }

    return eA;

}

@SuppressWarnings("checkstyle:IllegalCatch")
private Entry<DataStoreClient, ActorRef> createDatastoreClient(
        final String shardName, final ActorContext actorContext)
        throws DOMDataTreeShardCreationFailedException {

    LOG.debug("{}: Creating distributed datastore client for shard {}", memberName, shardName);
    final Props distributedDataStoreClientProps =
            SimpleDataStoreClientActor.props(memberName, "Shard-" + shardName, actorContext, shardName);

    final ActorRef clientActor = actorSystem.actorOf(distributedDataStoreClientProps);
    try {
        return new SimpleEntry<>(SimpleDataStoreClientActor
                .getDistributedDataStoreClient(clientActor, 30, TimeUnit.SECONDS), clientActor);
    } catch (final Exception e) {
        LOG.error("{}: Failed to get actor for {}", distributedDataStoreClientProps, memberName, e);
        clientActor.tell(PoisonPill.getInstance(), noSender());
        throw new DOMDataTreeShardCreationFailedException(
                "Unable to create datastore client for shard{" + shardName + "}", e);
    }
}

public void getContentURIsFromSmali(String smaliPath){

    this.contentURIs = new ArrayList<String>();
    ArrayList<String> contents = new ArrayList<String>();
    ArrayList<SimpleEntry> contentsReturn =new ArrayList<SimpleEntry>(); 
    SearchUtil searcher = new SearchUtil();
    String contentUri;

    contents = searcher.search4KeyInDir(smaliPath, "content://");

    for (String c:contents){
        if (!"".equals(contentUri = this.correctContentUri(c)))
            this.contentURIs.add(contentUri);
    }
    this.contentURIs = this.removeDuplicates(this.contentURIs);
}

private SimpleEntry<String, Integer> parseRaw(byte[] input, int index) {
    StringBuilder result = new StringBuilder();
    int advance = 0;
    ArrayList<Byte> raw = new ArrayList<>();
    while (!isKnownByte(input[index + advance])) {
        raw.add(input[index + advance]);
        advance++;
        if (index + advance >= input.length)
            break;
        if (conditionalLengths.size() > 0 && conditionalIndexes.size() > 0) {
            if (index + advance >= conditionalLengths.peek() + conditionalIndexes.peek())
                break;
        }
    }
    advance--;

    result.append("raw(");
    for (int x = 0; x < raw.size(); x++) {
        result.append(Integer.toHexString(raw.get(x) & 0xFF));
        if (x < raw.size() - 1)
            result.append(",");
        else
            result.append(")");
    }
    return new SimpleEntry<>(result.toString(), advance);
}

private SimpleEntry<String, Integer> parseRaw(byte[] input, int index, int length) {
    StringBuilder result = new StringBuilder();
    int advance = length - 1;
    ArrayList<Byte> raw = new ArrayList<>();
    for (int x = 0; x < length; x++)
        raw.add(input[index + x]);
    result.append("raw(");
    for (int x = 0; x < raw.size(); x++) {
        result.append(Integer.toHexString(raw.get(x) & 0xFF));
        if (x < raw.size() - 1)
            result.append(",");
        else
            result.append(")");
    }

    return new SimpleEntry<>(result.toString(), advance);
}

private SimpleEntry<String, Integer> parseReturn(byte[] input, int index) {
    String result;
    int advance = 2;
    int returnPoint = (ScriptUtils.shortFromByteArray(input, index + 1) + 3) * -1; // Return markers will always use a negative value.
    if (savedPoints.containsKey(index - returnPoint)) {
        int point = savedPoints.get(index - returnPoint);
        int line = point + lineNumber;

        //Special case fix for A002_OP1 bev file.
        if (input[index - returnPoint] != 0x47 && (decompiled.get(point).startsWith("ev::") || decompiled.get(point).startsWith("bev::"))) {
            return this.parseRaw(input, index, 3);
        }

        result = "goto(" + line + ")";
        return new SimpleEntry<>(result, advance);
    } else {
        return this.parseRaw(input, index, 3);
    }
}

private SimpleEntry<Boolean, Integer> hasEndConditional(byte[] input) {
    if (conditionalLengths.size() > 0 && conditionalIndexes.size() > 0) {
        int currentConditionalLength = conditionalLengths.peek();
        int currentConditionalIndex = conditionalIndexes.peek();
        int checkIndex = currentConditionalLength + currentConditionalIndex - 3;
        if (checkIndex < input.length) {
            for (byte b : CONDITIONAL_VALS) {
                if (ScriptUtils.shortFromByteArray(input, checkIndex + 1) < 0)
                    return new SimpleEntry<>(false, checkIndex); // The ending is a goto.
                if (input[checkIndex] == b)
                    return new SimpleEntry<>(true, checkIndex); // Ends in an else statement.
            }
        }
    }
    return new SimpleEntry<>(false, -1);
}

static <A> Entry<A, Double> selectLikelyEntry(TreeMap<A, Double> entries)
{
    ArrayList<A> keys = new ArrayList<A>(entries.keySet());

    Double value;
    A randomKey;

    do
    {           
        randomKey = keys.get(random.nextInt(keys.size()));
        value = entries.get(randomKey);

        //System.out.println("thinking to talk about " + randomKey + " + " + value + "("+keys.size()+" keys)");
    }
    while(value==null || (Math.random() > value.doubleValue()));

    return new SimpleEntry<A, Double>(randomKey, value);
}

@Nullable
@Override
public String getShardNameForPrefix(@Nonnull final DOMDataTreeIdentifier prefix) {
    Preconditions.checkNotNull(prefix, "prefix should not be null");

    Entry<DOMDataTreeIdentifier, PrefixShardConfiguration> bestMatchEntry =
            new SimpleEntry<>(
                    new DOMDataTreeIdentifier(prefix.getDatastoreType(), YangInstanceIdentifier.EMPTY), null);

    for (Entry<DOMDataTreeIdentifier, PrefixShardConfiguration> entry : prefixConfigMap.entrySet()) {
        if (entry.getKey().contains(prefix) && entry.getKey().getRootIdentifier().getPathArguments().size()
                > bestMatchEntry.getKey().getRootIdentifier().getPathArguments().size()) {
            bestMatchEntry = entry;
        }
    }

    //TODO we really should have mapping based on prefix instead of Strings
    return ClusterUtils.getCleanShardName(bestMatchEntry.getKey().getRootIdentifier());
}

private StreamEx<?> wrap(final Object data) {
    return Match(data).of(
            Case($(isNull()), () -> {
                throw new IllegalArgumentException(format(
                        "Nothing to return from data supplier. The following test will be skipped: %s.%s.",
                        testMethod.getConstructorOrMethod().getDeclaringClass().getSimpleName(),
                        testMethod.getConstructorOrMethod().getName()));
            }),
            Case($(instanceOf(Collection.class)), d -> StreamEx.of((Collection<?>) d)),
            Case($(instanceOf(Map.class)), d -> EntryStream.of((Map<?, ?>) d).mapKeyValue(SimpleEntry::new)),
            Case($(instanceOf(Map.Entry.class)), d -> StreamEx.of(d.getKey(), d.getValue())),
            Case($(instanceOf(Object[].class)), d -> StreamEx.of((Object[]) d)),
            Case($(instanceOf(double[].class)), d -> DoubleStreamEx.of((double[]) d).boxed()),
            Case($(instanceOf(int[].class)), d -> IntStreamEx.of((int[]) d).boxed()),
            Case($(instanceOf(long[].class)), d -> LongStreamEx.of((long[]) d).boxed()),
            Case($(instanceOf(Stream.class)), d -> StreamEx.of((Stream<?>) d)),
            Case($(instanceOf(Tuple.class)), d -> StreamEx.of(((Tuple) d).toSeq().toJavaArray())),
            Case($(), d -> StreamEx.of(d)));
}

JsonParser() {
  ParserCombinatorReference<JsonElement> jsonParser = newRef();

  ParserCombinator<JsonElement> jsonNullParser = string("null").map(v -> new JsonNull());

  ParserCombinator<JsonElement> jsonBooleanParser =
      regex("(true|false)").map(v -> new JsonPrimitive(Boolean.valueOf(v)));
  ParserCombinator<JsonElement> jsonIntegerParser =
      regex("[0-9]+").map(v -> new JsonPrimitive(Integer.parseInt(v)));
  ParserCombinator<JsonElement> jsonStringParser =
      regexMatchResult("\"([^\"]*)\"").map(v -> new JsonPrimitive(v.group(1)));
  ParserCombinator<JsonElement> jsonPrimitiveParser =
      jsonStringParser.or(jsonBooleanParser).or(jsonIntegerParser);

  ParserCombinatorReference<JsonElement> jsonObjectParser = newRef();
  ParserCombinatorReference<JsonElement> jsonArrayParser = newRef();

  ParserCombinator<Entry<String, JsonElement>> jsonObjectEntryParser =
      jsonStringParser.skip(string(":")).next(jsonParser)
          .map(pair -> new SimpleEntry<>(pair.first.toString(), pair.second));

  jsonObjectParser.setCombinator(
      skip(string("{"))
          .next(jsonObjectEntryParser.many(string(",")))
          .skip(string("}"))
          .map(JsonObject::new));

  jsonArrayParser.setCombinator(
      skip(string("["))
          .next(jsonParser.many(string(",")))
          .skip(string("]"))
          .map(JsonArray::new));

  jsonParser.setCombinator(
      jsonNullParser.or(jsonPrimitiveParser).or(jsonArrayParser).or(jsonObjectParser));

  parser = jsonParser.end();
}

@Test
public void shouldParseSimpleJsonObject() {
  JsonObject jsonObject = new JsonObject(
      new SimpleEntry<>("foo", new JsonPrimitive("bar")));

  assertEquals(jsonObject, jsonParser.apply("{\"foo\":\"bar\"}"));
}

@Override
protected ContextCustomizer createContextCustomizer(DoubleRegistry doubleRegistry) {
    return new MockContextCustomizer(
            MockitoDoubleFactory.class,
            doubleRegistry,
            Stream
                    .of(new SimpleEntry<>(SkipMockitoBeansPostProcessing.BEAN_NAME, skipMockitoBeansPostProcessing()))
                    .collect(toMap(Map.Entry::getKey, Map.Entry::getValue)));
}

@Test
public void shouldParseNestedArraysAndObjects() {
  JsonArray firstArray =
      new JsonArray(
          new JsonObject(new SimpleEntry<>("1", new JsonArray(
              new JsonObject(new SimpleEntry<>("1", new JsonPrimitive(1))),
              new JsonObject(new SimpleEntry<>("2", new JsonPrimitive(2)))))),
          new JsonObject(new SimpleEntry<>("2", new JsonArray(
              new JsonObject(new SimpleEntry<>("1", new JsonPrimitive(3))),
              new JsonObject(new SimpleEntry<>("2", new JsonPrimitive(4)))))));

  JsonArray secondArray =
      new JsonArray(
          new JsonObject(new SimpleEntry<>("1", new JsonArray(
              new JsonObject(new SimpleEntry<>("1", new JsonPrimitive(5))),
              new JsonObject(new SimpleEntry<>("2", new JsonPrimitive(6)))))),
          new JsonObject(new SimpleEntry<>("2", new JsonArray(
              new JsonObject(new SimpleEntry<>("1", new JsonPrimitive(7))),
              new JsonObject(new SimpleEntry<>("2", new JsonPrimitive(8)))))));

  JsonObject jsonObject = new JsonObject(
      new SimpleEntry<>("1", firstArray),
      new SimpleEntry<>("2", secondArray));

  String firstArrayJson = "[{\"1\":[{\"1\":1},{\"2\":2}]},{\"2\":[{\"1\":3},{\"2\":4}]}]";
  String secondArrayJson = "[{\"1\":[{\"1\":5},{\"2\":6}]},{\"2\":[{\"1\":7},{\"2\":8}]}]";
  String json = String.format("{\"1\":%s,\"2\":%s}", firstArrayJson, secondArrayJson);

  assertEquals(jsonObject, jsonParser.apply(json));
}

@Test
public void cancel_dialog() throws CalendarWriteException {
  //given
  //when
  HttpEntity<String> request = buildRequestWithSession("AMAZON.CancelIntent",
    new SimpleEntry<>(KEY_DIALOG_TYPE, DIALOG_TYPE_NEW_EVENT)
  );

  final SpeechletResponseEnvelope response = perform(request);

  //then
  assertEquals(
      ((PlainTextOutputSpeech)toTestBasic.speechService.speechCancelNewEvent(Locale.GERMANY)).getText(),
      ((PlainTextOutputSpeech)response.getResponse().getOutputSpeech()).getText());
}

/**
 * Id (aka configuration name) isn't modeled on the actual {@link NotificationConfiguration}
 * class but as the key name in the map of configurations in
 * {@link BucketNotificationConfiguration}
 */
@Override
public Entry<String, NotificationConfiguration> unmarshall(StaxUnmarshallerContext context) throws Exception {
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) {
        targetDepth += 1;
    }

    T topicConfig = createConfiguration();
    String id = null;

    while (true) {
        XMLEvent xmlEvent = context.nextEvent();
        if (xmlEvent.isEndDocument()) {
            return new SimpleEntry<String, NotificationConfiguration>(id, topicConfig);
        }

        if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {
            if (handleXmlEvent(topicConfig, context, targetDepth)) {
                // Do nothing, subclass has handled it
            } else if (context.testExpression("Id", targetDepth)) {
                id = StringStaxUnmarshaller.getInstance().unmarshall(context);
            } else if (context.testExpression("Event", targetDepth)) {
                topicConfig.addEvent(StringStaxUnmarshaller.getInstance().unmarshall(context));
            } else if (context.testExpression("Filter", targetDepth)) {
                topicConfig.setFilter(FilterStaxUnmarshaller.getInstance().unmarshall(context));
            }
        } else if (xmlEvent.isEndElement()) {
            if (context.getCurrentDepth() < originalDepth) {
                return new SimpleEntry<String, NotificationConfiguration>(id, topicConfig);
            }
        }
    }
}

private void parseLine(String line) {
    String[] key_value = line.split(": ");
    String key = key_value[0].replaceAll("^\"|\"$", "");
    String[] values = key_value[1].split(",");

    if (key.equals("Algorithm")) {
        algo = values[0];
    } else if (key.equals("NetworkGenerator")) {
        netGen = values[0];
    } else if (key.equals("Metrics")) {
        metrics = Arrays.asList(values);
    } else if (key.equals("ResourceGenerators")) {
        resGens = Arrays.asList(values);
    } else if (key.equals("DemandGenerators")) {
        demGens = Arrays.asList(values);
    } else if (key.equals("Runs")) {
        runs = Integer.parseInt(values[0]);
    } else if (key.equals("SaveNetworks")) {
        if (values[0].equals("") 
                || values[0].equals("XML") 
                || values[0].equals("DOT")) {
            saveNetworks = values[0];
        }
    } else if (key.equals("AlgorithmParameter")) {
        parseAlgoParamLine(values);
    } else {
        SimpleEntry<String, Object[]> entry = parseParamLine(key, values);
        params.add(entry);
    }
}

@Test
public void parameterAnnotationProcessing_withPathParameter() {
    List<MethodMetadata> visit = methodMetadataFactory.build(ReactiveClientWithPathParameters.class, URI.create(""));
    assertThat(visit)
            .hasSize(1);
    MethodMetadata requestTemplate = visit.get(0);
    assertThat(requestTemplate.getRequestTemplate().getVariableIndexToName())
            .contains(new SimpleEntry<>(0, singletonList("pathVariable1")),
                    new SimpleEntry<>(1, singletonList("pathVariable2")));
}

@Before
public void setUp() {
    this.builder = RuleSetBuilder.creator("commissions",
            Arrays.asList("EXMETHOD", "EXCHANGE", "PRODUCT", "REGION", "ASSET"));

    this.builder.with(RuleSetBuilder::rule, RuleBuilder.creator()
            .with(RuleBuilder::input, Arrays.asList("*", "VG:CMEGroup:CME:CBOT", "*", "*", "INDEX"))
            .with(RuleBuilder::output, Collections.singletonMap("Rate", "1.1")));

    this.builder.with(RuleSetBuilder::rule, RuleBuilder.creator()
            .with(RuleBuilder::input, Arrays.asList("*", "CME", "S&P", "*", "INDEX"))
            .with(RuleBuilder::output, Collections.singletonMap("Rate", "1.2")));

    this.builder.with(RuleSetBuilder::rule, RuleBuilder.creator()
            .with(RuleBuilder::input, Arrays.asList("VOICE", "CME", "ED", "*", "RATE"))
            .with(RuleBuilder::output, Collections.singletonMap("Rate", "1.4")));

    this.builder.with(RuleSetBuilder::rule, RuleBuilder.creator()
            .with(RuleBuilder::input, Arrays.asList("*", "*", "*", "US", "*"))
            .with(RuleBuilder::output, Collections.singletonMap("Rate", "1.5")));

    this.builder.with(RuleSetBuilder::rule, RuleBuilder.creator()
            .with(RuleBuilder::input, Arrays.asList("*", "*", "*", "UK", "*"))
            .with(RuleBuilder::output, Stream.of(
                    new SimpleEntry<>("Rate", "1.1"),
                    new SimpleEntry<>("Unit", "£"))
                    .collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue))));
}

private Element findElementWithMostParagraphs(Element main) {
    return main.getAllElements()
            .stream()
            .filter(e -> e.childNodes().stream().filter(n -> n instanceof Element).map(n -> (Element) n).anyMatch(el -> Objects.equals(el.tagName(), "p")))
            .map(e -> new SimpleEntry<>(e, e.getElementsByTag("p").size()))
            .sorted((e1, e2) -> e2.getValue() - e1.getValue())
            .map(SimpleEntry::getKey)
            .findFirst()
            .orElse(main);

}

@Override
public void deleteSession(
    final Session session
) {
  LOGGER.info(
      "Delete session: topic='{}', partition='{}'",
      session.getTopic(),
      session.getPartition()
  );

  synchronized (activeCommands) {
    // create command
    SimpleEntry<Session, TopicRoute> command = new SimpleEntry<>(session, null);

    // when another command is scheduled, cancel it
    if (activeCommands.containsKey(command)) {
      activeCommands.remove(command).cancel(false);
    }

    // schedule creation of session
    ScheduledFuture commandFuture = executorService.scheduleWithFixedDelay(
        () -> {
          if (sendDeleteSession(
              routingServiceCommandInterface,
              targetRoutingService,
              session
          )) {
            activeCommands.remove(command).cancel(false);
          }
        },
        0,
        retryDelay,
        retryDelayTimeUnit
    );

    // add command to scheduled commands
    activeCommands.put(command, commandFuture);
  }
}

/**
 * Primary Constructor.
 *
 * @param startSignal - Latch start signal
 * @param blockingNotificationQueue - Blocking Queue assigned to the worker
 */
public HTTPNotifier(CountDownLatch startSignal,
        BlockingQueue<AbstractMap.SimpleEntry<Uri,Notification>> blockingNotificationQueue) {
    this.run = false;
    this.startSignal = startSignal;
    this.blockingNotificationQueue = blockingNotificationQueue;
    handler = new BasicResponseHandler();
    this.api = new DpnAPI2(ZMQClientPool.getInstance().getWorker());
}

/**
 * As in different functions in Searcher
 * @param hits  ARraylist of SimpleEntry, obtained after searching for a key
 * @param toBeReplaced  Replace the long path name, such as TicklerVars.jClassDir
 * @param replacement   Replacement such as [Data_Dir]
 */
public static void printSimpleEntryArray(ArrayList<SimpleEntry> hits, String toBeReplaced, String replacement) {
    if (!hits.isEmpty()){
        OutBut.printNormal(hits.size()+" Search Results are found :\n===============================\n");
        for (SimpleEntry e: hits){
            String filePath = e.getKey().toString().replaceAll(toBeReplaced, replacement); 
            System.out.println("#FileName: "+filePath);
            System.out.println(" "+e.getValue()+"\n");
        }

        OutBut.printStep("Where "+replacement+" is "+toBeReplaced);
    }
}

/**
 * After searching for a key in files (which is faster), Refine the search by searching for a regex in the first search's result. 
 * @param eArray
 * @param regex
 * @return
 */
public ArrayList<SimpleEntry> refineSearch(ArrayList<SimpleEntry> eArray, String regex){
    ArrayList<SimpleEntry> result = new ArrayList<>();
    ArrayList<String> regexResult = new ArrayList<>();
    for (SimpleEntry e: eArray){
        regexResult = OtherUtil.getRegexFromString(e.getValue().toString(), regex);
        if (!regexResult.isEmpty())
            result.add(e);
    }

    return result;
}

/**
 * Search for any possible use of external storage
 */
public void externalStorageInCode(){
    OutBut.printH2("Possible External Storage");
    ArrayList<SimpleEntry> eArray = this.sU.searchForKeyInJava("getExternal",this.codeRoot);

    this.printE(eArray);

}

/**
 * Search for weak hashes
 */
private void weakCyphers() {
    System.out.println("\n");
    String[] weakCrypto = {"Rot13", "MD4", "MD5", "RC2", "RC4", "SHA1"};
    OutBut.printH2("Possible use of weak Ciphers/hashes");

    ArrayList<SimpleEntry> eA = new ArrayList<>();

    for (String c : weakCrypto)
        eA.addAll(this.sU.searchForKeyInJava(c,this.codeRoot));

    this.printE(eA);
}

/**
 * Use of cryptography 
 */
private void crypto(){
    OutBut.printH2("Crypto and hashing keywords");
    String[] keys = {"aes", "crypt", "cipher", "sha1", "sha2"};
    ArrayList<SimpleEntry> eA = this.returnFNameLineGroup(keys, false);

    this.printE(this.removeDuplicatedSimpleEntries(eA));
}

@Test
public void requestHeaders_withList() {
    RequestHeaders requestHeaders = getDynamic("header1", 0);

    HttpHeaders httpHeaders = requestHeaders.encode(new Object[]{asList(12.23D, 234.321D)});
    Assertions.assertThat(httpHeaders)
            .containsExactly(new SimpleEntry<>("header1", asList("12.23", "234.321")));
}

@Test
public void requestHeaders_withDynamicHeader() {
    RequestHeaders requestHeaders = getDynamic("header1", 0);

    HttpHeaders httpHeaders = requestHeaders.encode(new Object[]{"headerDynamicHeader"});
    Assertions.assertThat(httpHeaders)
            .containsExactly(new SimpleEntry<>("header1", singletonList("headerDynamicHeader")));
}

public static <K, V, W extends Iterable<V>> Entry<K, V> pollFirstEntry(NavigableMap<K, W> map) {
    Entry<K, V> result = null;

    Iterator<Entry<K, W>> itE = map.entrySet().iterator();

    // For robustness, remove entry valueX sets
    while(itE.hasNext()) {
        Entry<K, W> e = itE.next();

        K k = e.getKey();
        Iterable<V> vs = e.getValue();

        Iterator<V> itV = vs.iterator();
        if(itV.hasNext()) {
            V v = itV.next();
            itV.remove();

            if(!itV.hasNext()) {
                itE.remove();
            }

            result = new SimpleEntry<>(k, v);
            break;
        } else {
            itE.remove();
            continue;
        }
    }

    return result;
}