continue
				}
				if wildcard.Match("tmp/*", u.Object) {
					continue
				}
				if wildcard.Match("multipart/*", u.Object) {
					continue
				}
				if wildcard.Match("tmp-old/*", u.Object) {
					continue
				}
			}

			now := time.Now()
			if now.Sub(u.Queued) < time.Second {
				// let recently failed networks to reconnect
				// making MRF wait for 1s before retrying,

     * Here we automatically accept the following cases:
     * - A setter `setX` of an upgraded property is removed
     * - A boolean `isX` of an upgraded property is removed
     * - A new getter `getX` is added, where the old getter is a boolean getter `isX` of an upgraded property
     * - A return type is changed for a getter `getX` of an upgraded property
     *

	log.SetFlags(0)
	log.SetPrefix("go_ios_exec: ")
	if debug {
		log.Println(strings.Join(os.Args, " "))
	}
	if len(os.Args) < 2 {
		log.Fatal("usage: go_ios_exec a.out")
	}

	// For compatibility with the old builders, use a fallback bundle ID
	bundleID = "golang.gotest"

	exitCode, err := runMain()
	if err != nil {
		log.Fatalf("%v\n", err)
	}
	os.Exit(exitCode)
}

func runMain() (int, error) {

                    .groupId("com.example")
                    .artifactId("test-project")
                    .version("1.0.0")
                    .dependency("junit", "junit", "3.8.1") // Old version that should be flagged
                    .build();
            Files.writeString(pomFile, originalPom);

            UpgradeContext context = TestUtils.createMockContext(tempDir);

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPut_supportedPresent() {
    assertEquals("put(present, value) should return the old value", v0(), getMap().put(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPut_supportedNotPresent() {

    for (int i = 0; i < keysAndValues.length; i += 2) {
      T key = keysAndValues[i];
      T value = keysAndValues[i + 1];
      T old = map.put(key, value);
      assertWithMessage("Key %s set to %s and %s", key, value, old).that(old).isNull();
    }
    return map;
  }

  private static <T extends @Nullable Object> Entry<T, T> entry(T key, T value) {

	<licenses>
		<license>
			<name>GNU Lesser General Public License, version 2.1</name>
			<url>http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt</url>
			<distribution>repo</distribution>
		</license>
	</licenses>
	<organization>
		<name>CodeLibs Project</name>
		<url>https://www.codelibs.org/</url>
	</organization>
	<developers>

        // Clean up leases older than 5ms
        int cleaned = leaseManager.cleanupExpiredLeases(5);

        // At least the first lease should be cleaned
        assertTrue(cleaned >= 1);

        // Check if old lease was removed
        LeaseEntry entry1 = leaseManager.getLease(key1);
        if (cleaned == 2) {
            assertNull(entry1);
            assertNull(leaseManager.getLease(key2));
        }
    }

import java.util.Set;

/**
 * Creates temporary files and directories whose permissions are restricted to the current user or,
 * in the case of Android, the current app. If that is not possible (as is the case under the very
 * old Android Ice Cream Sandwich release), then this class throws an exception instead of creating
 * a file or directory that would be more accessible.
 */
@J2ktIncompatible
@GwtIncompatible
@J2ObjCIncompatible

///

#### Use Cases with Early Exit Code { #use-cases-with-early-exit-code }

There are some use cases with specific conditions that could benefit from the old behavior of running the exit code of dependencies with `yield` before sending the response.