<p>isInSutList.</p>

@param sut a {@link com.greenpepper.server.domain.SystemUnderTest} object.
@param sutList a {@link java.util.Collection} object.
@return a boolean.
420069
public boolean isInSutList(SystemUnderTest sut, Collection<SystemUnderTest> sutList) {
        for (SystemUnderTest aSut : sutList) {
            if (aSut.equalsTo(sut)) {
                return true;
            }
        }

        return false;
    }
1123862
public boolean isList() {
    Object ptr = cdr;
    while (ptr instanceof ConsValue) {
      ptr = ((ConsValue) ptr).cdr;
    }
    return ptr == ConstantValue.NIL;
  }
929048
private boolean isInWhiteList(String tpl)
	{
		if ((!whiteList.isEmpty() && whiteList.contains(tpl))
				|| (whiteList.isEmpty())) {
			return true;
		}
		return false;
	}
1071780
public boolean contains(MappeableContainer subset) {
    if(subset instanceof MappeableRunContainer) {
      return contains((MappeableRunContainer)subset);
    } else if(subset instanceof MappeableArrayContainer) {
      return contains((MappeableArrayContainer) subset);
    } else if(subset instanceof MappeableBitmapContainer){
      return contains((MappeableBitmapContainer)subset);
    }
    return false;
  }
332520
public static boolean contains (int[] list, int value)
    {
        int llength = list.length; // no optimizing bastards
        for (int i = 0; i < llength; i++) {
            if (list[i] == value) {
                return true;
            }
        }
        return false;
    }
573350
private boolean isSoilAnalysisExist(ArrayList<HashMap> icSubArr) {

        for (HashMap icSubData : icSubArr) {
            if (!getValueOr(icSubData, "slsc", "").equals("")) {
                return true;
            }
        }
        return false;
    }
1300679
public static <T> void checkIsFullCut(Set<T> inputSet, T root, Deps<T> deps) {
        // Check that the input set defines a full cut through the graph with outMod as root.
        HashSet<T> visited = new HashSet<T>();        
        // Mark the inputSet as visited. If it is a valid leaf set, then leaves will be empty upon
        // completion of the DFS.
        visited.addAll(inputSet);
        HashSet<T> leaves = dfs(root, visited, deps);
        if (leaves.size() != 0) {
            throw new IllegalStateException("Input set is not a valid leaf set for the given output module. Extra leaves: " + leaves);
        }
    }
332726
public static boolean hasPlrselPart(List<SoyMsgPart> msgParts) {
    for (SoyMsgPart origMsgPart : msgParts) {
      if (origMsgPart instanceof SoyMsgPluralPart || origMsgPart instanceof SoyMsgSelectPart) {
        return true;
      }
    }
    return false;
  }
505538
public static <T> boolean isNotIn(T t, List<T> ts) {
        return isNotIn(t, ts.toArray());
    }
645282
@Override
    public boolean checkCondition(IValue test) throws FilterException {
        Iterator iter = values.iterator();
        while (iter.hasNext()) {
            IValue value = (IValue) iter.next();
            if (value.containedBy(test)) {
                return true;
            }
        }
        return false;
    }
256632
public boolean isSubtypesUnchecked(List<Type> ts, List<Type> ss, Warner warn) {
        while (ts.tail != null && ss.tail != null
               /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ &&
               isSubtypeUnchecked(ts.head, ss.head, warn)) {
            ts = ts.tail;
            ss = ss.tail;
        }
        return ts.tail == null && ss.tail == null;
        /*inlined: ts.isEmpty() && ss.isEmpty();*/
    }
845419
private boolean isUnidirestionalList(RelationshipList list) {
        if (list.size() > 0) {
            try {
                if (((AsymmetricRelationship) list.get(0)).getCommonParentIndex() == 0) {
                    return true;
                }
            } catch (java.lang.IndexOutOfBoundsException ex) {
                return true;
            }
        }
        return false;
    }
1239856
public static boolean contains(List<LatLong> latLongs, LatLong latLong) {
        boolean result = false;
        for (int i = 0, j = latLongs.size() - 1; i < latLongs.size(); j = i++) {
            if ((latLongs.get(i).latitude > latLong.latitude) != (latLongs.get(j).latitude > latLong.latitude)
                    && (latLong.longitude < (latLongs.get(j).longitude - latLongs.get(i).longitude) * (latLong.latitude - latLongs.get(i).latitude)
                    / (latLongs.get(j).latitude - latLongs.get(i).latitude) + latLongs.get(i).longitude)) {
                result = !result;
            }
        }
        return result;
    }
391903
public static boolean hasJUnitAnnotation(MethodTree tree, VisitorState state) {
    MethodSymbol methodSym = getSymbol(tree);
    if (methodSym == null) {
      return false;
    }
    if (hasJUnitAttr(methodSym)) {
      return true;
    }
    return findSuperMethods(methodSym, state.getTypes()).stream()
        .anyMatch(JUnitMatchers::hasJUnitAttr);
  }
1041538
boolean isEmpty(Map<String, List<List<RepositoryResource>>> installResources) {
        if (installResources == null)
            return true;
        for (List<List<RepositoryResource>> targetList : installResources.values()) {
            for (List<RepositoryResource> mrList : targetList) {
                if (!mrList.isEmpty())
                    return false;
            }
        }
        return true;
    }
951794
public synchronized static boolean hasSudo()
	{
		if (!sudoTested)
		{
			String[] cmdArr = new String[]{"which", "sudo"};
			List<String> cmd = new ArrayList<String>(cmdArr.length);
			Collections.addAll(cmd, cmdArr);

			ProcessBuilder whichsudo = new ProcessBuilder(cmd);

			try
			{
				Process p = whichsudo.start();
				try
				{
					Execed e = new Execed(cmd, p, false);

					// Let it run
					int returnCode = e.waitForExit(new Deadline(3, TimeUnit.SECONDS));

					sudoSupported = (returnCode == 0);
					sudoTested = true;
				}
				finally
				{
					p.destroy();
				}
			}
			catch (Throwable t)
			{
				sudoSupported = false;
				sudoTested = true;
			}
		}

		return sudoSupported;
	}
1269735
public static <T> boolean listContainsDuplicates(List<T> list) {
        return list.size() != new HashSet<>(list).size();
    }