if (methodLinkMetaData.name.equals(method)) {
                candidates.add(methodLinkMetaData);
            }
        }
        if (candidates.isEmpty()) {
            String message = String.format("No method '%s' found for class '%s'.\nFound the following methods:", method, className);
            for (MethodLinkMetaData methodLinkMetaData : methods.values()) {

        Model model = builder.build(session, project, Sources.buildSource(file));

        assertNotNull(model);
        assertTrue(model.getProfiles().isEmpty());
    }

    @Test
    void testScmInheritance() throws Exception {
        Model model = Model.newBuilder()
                .scm(Scm.newBuilder()

          @Override
          public @Nullable Object getIfPresent(Object key) {
            return null;
          }
        };

    assertThat(cache.getAllPresent(ImmutableList.of(new Object()))).isEmpty();
  }

  public void testGetAllPresent_cached() {
    Object cachedKey = new Object();
    Object cachedValue = new Object();
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {

        if (rev != null || timestamp != null) {
            msg += " (";
            msg += (rev != null ? rev : "");
            if (timestamp != null && !timestamp.isEmpty()) {
                String ts = formatTimestamp(Long.parseLong(timestamp));
                msg += (rev != null ? "; " : "") + ts;
            }
            msg += ")";
        }
        return msg;
    }

    Thread.setDefaultUncaughtExceptionHandler { _, throwable ->
      initUncaughtException(throwable)
    }

    taskQueuesWereIdle = TaskRunner.INSTANCE.activeQueues().isEmpty()

    applyLogger {
      addHandler(testLogHandler)
      level = Level.FINEST
      useParentHandlers = false
    }
  }

  @SuppressLint("NewApi")

   *
   * @return {@code true} if the iterable contains no elements
   */
  public static boolean isEmpty(Iterable<?> iterable) {
    if (iterable instanceof Collection) {
      return ((Collection<?>) iterable).isEmpty();
    }
    return !iterable.iterator().hasNext();
  }

  /**

      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null
      } else if (methodName == "protocols" && callArgs.isEmpty()) {
        return protocols // Client advertises these protocols.
      } else if ((methodName == "selectProtocol" || methodName == "select") &&
        String::class.java == returnType &&
        callArgs.size == 1 &&

            }
        }
    }

    private void injectDependencyDefaults(List<Dependency> dependencies) {
        for (Dependency dependency : dependencies) {
            if (StringUtils.isEmpty(dependency.getScope())) {
                // we cannot set this directly in the MDO due to the interactions with dependency management
                dependency.setScope("compile");
            }
        }
    }

            context.reader =
                    LineReaderBuilder.builder().terminal(context.terminal).build();

            if (context.options().goals().isEmpty()
                    || context.options().goals().get().size() != 1) {
                return badGoalsErrorMessage("No goal or multiple goals specified, specify only one goal.", context);
            }

            context.reader =
                    LineReaderBuilder.builder().terminal(context.terminal).build();

            if (context.options().goals().isEmpty()) {
                return badGoalsErrorMessage("No goals specified.", context);
            }

            String goalName = context.options().goals().get().get(0);
            Goal goal = context.goals.get(goalName);