}

var X, Y T

const N = 1000

func main() {
	// Keep GC running so the write barrier is on.
	go func() {
		for {
			runtime.GC()
		}
	}()

	for i := 0; i < N; i++ {
		runtime.Gosched()
		f()
		if X != Y {
			panic("FAIL")
		}
	}

package p2

import "runtime"

func E() func() int { return runtime.NumCPU }

func F() func() { return runtime.GC }

func G() func() string { return runtime.GOROOT }

func H() func() { return runtime.Gosched }

func Issue1560FromC() {
	for atomic.LoadInt32(&issue1560) != 1 {
		runtime.Gosched()
	}
	atomic.AddInt32(&issue1560, 1)
	for atomic.LoadInt32(&issue1560) != 3 {
		runtime.Gosched()
	}
	issue1560Ch <- true
}

func Issue1560FromGo() {
	atomic.AddInt32(&issue1560, 1)
	for atomic.LoadInt32(&issue1560) != 2 {
		runtime.Gosched()
	}
	atomic.AddInt32(&issue1560, 1)
	issue1560Ch <- true
}

}

func ssender(c chan string, strobe chan bool) {
	c <- "hello again"
	strobe <- true
}

var ticker = time.Tick(10 * 1000) // 10 us
func sleep() {
	<-ticker
	<-ticker
	runtime.Gosched()
	runtime.Gosched()
	runtime.Gosched()
}

const maxTries = 10000 // Up to 100ms per test.

func main() {
	var i32 int32
	var i64 int64
	var b bool
	var s string

	var sync = make(chan bool)

	DB.Save(&animal).Update("From", "a nice place") // The name field should be untouched
	DB.First(&animal, animal.Counter)
	if animal.Name != "galeone" {
		t.Errorf("Name fields shouldn't be changed if untouched, but got %v", animal.Name)
	}

	// When changing a field with a default value, the change must occur
	animal.Name = "amazing horse"
	DB.Save(&animal)

	if err != nil {
		return err
	}

	return pledge(pptr, exptr)
}

// PledgePromises implements the pledge syscall.
//
// This changes the promises and leaves the execpromises untouched.
//
// For more information see pledge(2).
func PledgePromises(promises string) error {
	if err := pledgeAvailable(); err != nil {
		return err
	}

	pptr, err := BytePtrFromString(promises)
	if err != nil {

		// Encourage main goroutine to move around to
		// different Ms and Ps.
		for atomic.LoadInt32(&done) == 0 {
			runtime.Gosched()
		}
		wg.Done()
	}()
	var want strings.Builder
	for i := 0; i < 1000; i++ {
		runtime.Dlog().I(i).End()
		fmt.Fprintf(&want, "[] %d\n", i)
		runtime.Gosched()
	}
	atomic.StoreInt32(&done, 1)
	wg.Wait()

	gotFull := runtime.DumpDebugLog()
	got := dlogCanonicalize(gotFull)

	var mu sync.Mutex
	c := make(chan []C.char, 100)
	for i := 0; i < 10; i++ {
		wg.Add(2)
		go func() {
			defer wg.Done()
			for i := 0; i < 100; i++ {
				c <- make([]C.char, 4096)
				runtime.Gosched()
			}
		}()
		go func() {
			defer wg.Done()
			for i := 0; i < 100; i++ {
				p := &(<-c)[0]
				mu.Lock()
				C.f(p)
				mu.Unlock()
			}
		}()
	}
	wg.Wait()

  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
}
node {
  name: "Mul"
  op: "Mul"
  input: "Add"
  input: "Add"
  # Empty device name should be kept untouched.
  device: ""
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
}
node {
  name: "Sub"
  op: "Sub"
  input: "Add"
  input: "Mul"
  # Device name is not modified if complete

        realizeComponents().exe.sources.asm.source.srcDirs*.name == ["d1", "d2"]
    }

    def "creates assemble tasks for each non-empty executable source set "() {
        when:
        touch("src/test/asm/dummy.s")
        touch("src/test/anotherOne/dummy.s")
        dsl {
            pluginManager.apply AssemblerPlugin

            model {
                components {
                    test(NativeExecutableSpec) {