this.components = components;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        Optional<T> optional = lookupOptional(type);
        if (optional.isPresent()) {
            return optional.get();
        } else {
            throw new LookupException("No mapping for key: " + type.getName());
        }
    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        return lookup(type);

                            List<String> parts = Arrays.stream(line.split(":", 2)).map(String::trim).collect(Collectors.toList());
                            String name = parts.get(0);
                            String value = parts.get(1);
                            // the ID of the CPU socket
                            if (name.equals("physical id")) {
                                currentID = value;

      List<LockGraphNode> acquiredLockList = requireNonNull(acquiredLocks.get());
      LockGraphNode node = lock.getLockGraphNode();
      // Iterate in reverse because locks are usually locked/unlocked in a
      // LIFO order.
      for (int i = acquiredLockList.size() - 1; i >= 0; i--) {
        if (acquiredLockList.get(i) == node) {
          acquiredLockList.remove(i);

                // Check field value follows convention
                field.setAccessible(true);
                String value = (String) field.get(null);
                assertNotNull("Field value should not be null: " + field.getName(), value);
                assertTrue("Field value should start with {labels.: " + field.getName() + " = " + value, value.startsWith("{labels."));

        thread.start();
        thread.join(1000);

        assertEquals(2, callbackResults.size());
        assertEquals("callback1", callbackResults.get(0));
        assertEquals("callback2", callbackResults.get(1));
    }

    @Test
    public void test_run_bufferSizeLimit() throws InterruptedException {
        StringBuilder inputBuilder = new StringBuilder();

        helper.setDuplicateHostList(testList);

        assertEquals(testList, helper.duplicateHostList);
        assertEquals(1, helper.duplicateHostList.size());
        assertEquals("www.test.com", helper.duplicateHostList.get(0).getRegularName());
    }

    @Test
    public void test_add() {
        DuplicateHostHelper helper = new DuplicateHostHelper();

        DuplicateHost testHost = new DuplicateHost();

    }

    @TaskAction
    fun generate() {
        IoActions.writeTextFile(outputFile.asFile.get(), object : ErroringAction<BufferedWriter>() {
            @Throws(Exception::class)
            public
            override fun doExecute(bufferedWriter: BufferedWriter) {
                val packages = Implementation(excludes.get(), includes.get()).collectPackages(classpath.files.map(File::toPath))

        traverser.forEach((ResourceHandler) (path, is) -> list.add(path));
        list.sort((s1, s2) -> s1.compareTo(s2));
        assertThat(list.size(), is(2));
        assertThat(list.get(0), is("junit/textui/ResultPrinter.class"));
        assertThat(list.get(1), is("junit/textui/TestRunner.class"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFromRootPackage_FileSystem() throws Exception {

    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    return (connectionsU != null) && connectionsU.successors().contains(nodeV);
  }

  private final @Nullable V edgeValueOrDefaultInternal(N nodeU, N nodeV, @Nullable V defaultValue) {
    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    V value = (connectionsU == null) ? null : connectionsU.value(nodeV);

            }
            reader = new StringReader(sb.toString());
        } else if (settings.get("synonyms_path") != null) {
            if (settings.getAsBoolean("dynamic_reload", false)) {
                final String filePath = settings.get("synonyms_path", null);

                if (filePath == null) {
                    throw new IllegalArgumentException("synonyms_path is not found.");