* part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

            }
            for (final String labelTypeValue : labelList) {
                for (final Map<String, String> map : labelTypeItems) {
                    if (map.get(Constants.ITEM_VALUE).equals(labelTypeValue)) {
                        buf.append(' ');
                        buf.append(map.get(Constants.ITEM_LABEL));
                        break;
                    }
                }
            }

        final List<Map<String, Object>> resList = new ArrayList<>();
        for (Map<String, Object> elem : logList) {
            if (elem.containsKey("job_name") && elem.get("job_name").equals(namePrefix + "Scheduler")) {
                resList.add(elem);
            }
        }
        return resList;
    }

    protected static List<Map<String, Object>> readLogItems(final String apiName) {

        MetadataGraphVertex v = new MetadataGraphVertex(md);
        v.setCompareVersion(versionedVertices);
        v.setCompareScope(scopedVertices);

        for (MetadataGraphVertex gv : vertices) {
            if (gv.equals(v)) {
                return gv;
            }
        }

        return null;
    }
    // ------------------------------------------------------------------------

    }

    public BiFunction<String, Matcher, String> createPathMatcher(final Matcher matcher, final String replacement) { // for PathMapping
        if (FUNCTION_ENCODEURL_MATCHER.equals(replacement)) {
            return (u, m) -> DocumentUtil.encodeUrl(u);
        }
        if (!replacement.startsWith(GROOVY_MATCHER)) {
            return (u, m) -> m.replaceAll(replacement);
        }

  public void testKeySetIteratorRemove() {
    int key0Count = multimap().get(k0()).size();
    Iterator<K> keyItr = multimap().keySet().iterator();
    while (keyItr.hasNext()) {
      if (keyItr.next().equals(k0())) {
        keyItr.remove();
      }
    }
    assertEquals(getNumElements() - key0Count, multimap().size());
    assertGet(k0());
  }

            ArtifactResult result = new ArtifactResult(request);
            results.add(result);

            Artifact artifact = request.getArtifact();
            if ("maven-test".equals(artifact.getGroupId())) {
                String scope = artifact.getArtifactId().substring("scope-".length());

                try {

                    + " Optional=" + (artifact.isOptional() ? "true" : "false"));
            assertTrue(
                    artifact.getVersion().equals("1.0"), "Incorrect version for " + artifact.getDependencyConflictId());
        }
    }

		t.Fatalf("member id is not equal: expects: %v, got: %v", profile.Refer, member.ProfileID)
	}

	DB.Model(&profile).Update("Refer", 100)

	var member2 Member
	if err := DB.First(&member2, "id = ?", member.ID).Error; err != nil {
		t.Fatalf("failed to find member, got error: %v", err)
	} else if member2.ProfileID != 100 {
		t.Fatalf("member id is not equal: expects: %v, got: %v", 100, member2.ProfileID)
	}

                String path,
                NtlmPasswordAuthentication auth) throws SmbAuthException {
        DfsReferral dr = null;
        long now = System.currentTimeMillis();

        if (DISABLED || root.equals("IPC$")) {
            return null;
        }
        /* domains that can contain DFS points to maps of roots for each
         */
        HashMap domains = getTrustedDomains(auth);
        if (domains != null) {