def "throws FileException when zip is badly formed"() {
        def file = temporaryFolder.file("badly-formed").createFile()

        when:
        FileZipInput.create(file)

        then:
        thrown(FileException)
    }

    // This documents current behaviour, not desired behaviour
    @Requires(UnitTestPreconditions.Jdk10OrEarlier)
    def "silently ignores zip that is badly formed"() {

class EclipseTestSourcesIntegrationTest extends AbstractEclipseTestSourcesIntegrationTest {

    @ToBeFixedForConfigurationCache
    def "source directories from main source sets are not marked with test classpath attribute"() {
        buildFile << """
            plugins {
                id 'java'
                id 'eclipse'
            }
        """
        file('src/main/java').mkdirs()

			os.Exit(1)
		}
		// Exit with the thread locked, which should exit the
		// main thread.
		ready <- true
	}()
	<-ready
	time.Sleep(1 * time.Millisecond)
	// Check that this goroutine is still running on a different
	// thread.
	if mainTID != 0 && gettid() == mainTID {
		println("goroutine migrated to locked thread")
		os.Exit(1)
	}
	println("OK")
}

func LockOSThreadAlt() {

	Stat() (fs.FileInfo, error)
}

// Lock places an advisory write lock on the file, blocking until it can be
// locked.
//
// If Lock returns nil, no other process will be able to place a read or write
// lock on the file until this process exits, closes f, or calls Unlock on it.
//
// If f's descriptor is already read- or write-locked, the behavior of Lock is
// unspecified.
//

                    forced()
                }
                edge("org:databind:{strictly 2.7.9}", "org:databind:2.7.9") {
                    byConstraint('belongs to platform org:platform:2.7.9')
                    forced()
                    module('org:annotations:2.7.9') {
                        byConstraint('belongs to platform org:platform:2.7.9')
                        forced()
                    }

	}

	// blocking on locked file
	locked := make(chan struct{}, 1)
	go func() {
		bl, blerr := LockedOpenFile(f.Name(), os.O_WRONLY, 0o600)
		if blerr != nil {
			t.Error(blerr)
			return
		}
		locked <- struct{}{}
		if blerr = bl.Close(); blerr != nil {
			t.Error(blerr)
			return
		}
	}()

	select {
	case <-locked:
		t.Error("unexpected unblocking")

    return {*this, "noinline-functions",
            llvm::cl::desc(
                "Name of the functions that should be marked "
                "tf._noinline = true to prevent inlining. The name of the "
                "function should exactly match to be marked noinline."),
            llvm::cl::list_init<std::string>(noinline_functions),
            llvm::cl::ZeroOrMore};
  }

     *
     * If {@code true}, each locked dependency is added as a strict constraint,
     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *

 * <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be
 * {@link Consumer} if it is not marked either {@link Consumer} or {@link Provider}.
 * <p>
 * A package can be marked {@link Provider}. In this case, all types in the package are considered
 * to be a provider type regardless of whether they are marked {@link Consumer} or {@link Provider}.
 *
 * @see Consumer

	if up == abi.UnsafePointUnsafe {
		// Unsafe-point marked by compiler. This includes
		// atomic sequences (e.g., write barrier) and nosplit
		// functions (except at calls).
		return false, 0
	}
	if fd := funcdata(f, abi.FUNCDATA_LocalsPointerMaps); fd == nil || f.flag&abi.FuncFlagAsm != 0 {
		// This is assembly code. Don't assume it's well-formed.
		// TODO: Empirically we still need the fd == nil check. Why?
		//