}
	matches, hash, err := buildid.FindAndHash(f, id, 0)
	f.Close()
	if err != nil {
		log.Fatal(err)
	}

	// <= go 1.7 doesn't embed the contentID or actionID, so no slash is present
	if !strings.Contains(id, "/") {
		log.Fatalf("%s: build ID is a legacy format...binary too old for this tool", file)
	}

	newID := id[:strings.LastIndex(id, "/")] + "/" + buildid.HashToString(hash)
	if len(newID) != len(id) {

        ImmutableSet.of(
            49, 51, 59, 163, 199, 321, 325, 363, 367, 469, 545, 561, 727, 769, 773, 781);
    for (int i = 1; i < 900; i += 2) {
      if (!falsePositives.contains(i)) {
        assertFalse("BF should not contain " + i, bf.mightContain(Integer.toString(i)));
      }
    }

    // Check that there are exactly 29824 false positives for this BF.
    int knownNumberOfFalsePositives = 29824;

        SmbException ex =
                assertThrows(SmbException.class, () -> new DirFileEntryEnumIterator1(tree, parent, "*", (ResourceNameFilter) null, 0));
        assertTrue(ex.getMessage().contains("directory must end with '/'"));
        verify(tree, times(1)).acquire();
        verify(tree, times(1)).release(); // closed after failure
    }

    @Test

            SmbException ex =
                    assertThrows(SmbException.class, () -> SmbCopyUtil.copyFile(src, dest, buffers, 8, new WriterThread(), sh, dh));
            assertTrue(ex.getMessage().contains("smb://src"));
            assertTrue(ex.getMessage().contains("smb://dest"));
        }

        @Test
        @DisplayName("copyFile swallows when ignoreCopyToException=true")
        void copyFile_swallowsWhenIgnoreTrue() throws Exception {

      assertThat(expected).hasMessageThat().contains("create(null)");
      return;
    }
    fail("should have failed");
  }

  public void testBadEquals_withParameterizedType() throws Exception {
    try {
      tester.testEquals(BadEqualsWithParameterizedType.class);
    } catch (AssertionError expected) {
      assertThat(expected).hasMessageThat().contains("create([[1]])");
      return;
    }

        Arrays.sort(newIngesters, (o1, o2) -> o1.priority - o2.priority);
        ingesters = newIngesters;
    }

    /**
     * Returns the array of registered ingesters sorted by priority.
     * The returned array contains all ingesters in priority order
     * (lower priority numbers first).
     *
     * @return the sorted array of ingesters
     */
    public Ingester[] getIngesters() {
        return ingesters;
    }

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@Nullable Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return singletonIterator(element);
  }

  @Override

@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@GwtIncompatible
abstract class AbstractRangeSet<C extends Comparable> implements RangeSet<C> {
  AbstractRangeSet() {}

  @Override
  public boolean contains(C value) {
    return rangeContaining(value) != null;
  }

  @Override
  public abstract @Nullable Range<C> rangeContaining(C value);

  @Override
  public boolean isEmpty() {
    return asRanges().isEmpty();

 */
package jcifs.ntlmssp.av;

import jcifs.Configuration;
import jcifs.internal.util.SMBUtil;

/**
 * NTLMSSP AV pair representing single host information in NTLM authentication.
 * Contains host-specific data used during the NTLM challenge-response process.
 *
 * @author mbechler
 */
public class AvSingleHost extends AvPair {

    /**
     * Constructs an AvSingleHost from raw byte data
     *

    void testToString() {
        // When
        String result = trans2SetFileInformation.toString();

        // Then
        assertTrue(result.startsWith("Trans2SetFileInformation["));
        assertTrue(result.contains("fid=" + fid));
    }