public void testBrowse () throws MalformedURLException, CIFSException {
        CIFSContext ctx = withAnonymousCredentials();
        try ( SmbFile smbFile = new SmbFile("smb://", ctx) ) {
            try ( CloseableIterator<SmbResource> it = smbFile.children() ) {
                while ( it.hasNext() ) {
                    try ( SmbResource serv = it.next() ) {
                        System.err.println(serv.getName());
                    }

        try ( SmbResource f = createTestFile() ) {
            try {
                assertCloseTime(f.createTime());
            }
            finally {
                f.delete();
            }
        }
    }


    @Test
    public void testSetCreated () throws CIFSException, MalformedURLException, UnknownHostException {
        try ( SmbResource f = createTestFile() ) {

  public void testCheckPositive_zeroInt() {
    try {
      MathPreconditions.checkPositive("int", 0);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {
      MathPreconditions.checkPositive("int", Integer.MIN_VALUE);

  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {

  protected Map<K, V> makeEitherMap() {
    try {
      return makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return makeEmptyMap();
    }
  }

  protected final boolean supportsValuesHashCode(Map<K, V> map) {
    // get the first non-null value
    Collection<V> values = map.values();
    for (V value : values) {
      if (value != null) {
        try {
          int unused = value.hashCode();

    }

    try {
      Helpers.assertContentsInOrder(list, "a", "b", "c", "d");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "B", "c");

  public void testCheckArgument_simple_failure() {
    try {
      Preconditions.checkArgument(false);
      fail("no exception thrown");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckArgument_simpleMessage_success() {
    Preconditions.checkArgument(true, IGNORE_ME);
  }

  public void testCheckArgument_simpleMessage_failure() {
    try {
      Preconditions.checkArgument(false, new Message());

    Iterators.addAll(copy, collection.iterator());

    try {
      collection.add(sampleElement);
      fail("add succeeded on unmodifiable collection");
    } catch (UnsupportedOperationException expected) {
    }

    assertCollectionsAreEquivalent(copy, collection);

    try {
      collection.addAll(siblingCollection);
      fail("addAll succeeded on unmodifiable collection");

        try ( SmbWatchHandle w = this.base
                .watch(FileNotifyInformation.FILE_NOTIFY_CHANGE_ATTRIBUTES | FileNotifyInformation.FILE_NOTIFY_CHANGE_LAST_WRITE, false) ) {
            try ( SmbFile cr = new SmbFile(this.base, "modified") ) {
                cr.createNewFile();
                setupWatch(w);
                try ( OutputStream os = cr.getOutputStream() ) {

    assertEquals(1, (int) iter.next());

    try {
      iter.peek();
      fail("peek() should throw NoSuchElementException at end");
    } catch (NoSuchElementException expected) {
    }

    try {
      iter.peek();
      fail("peek() should continue to throw NoSuchElementException at end");
    } catch (NoSuchElementException expected) {
    }

    try {
      iter.next();