#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define fd (30)

// Tests libgo2.so, which does not export any functions.
// Read a string from the file descriptor and print it.
int main(void) {
  int i;
  ssize_t n;
  char buf[20];
  struct timespec ts;

  // The descriptor will be initialized in a thread, so we have to
  // give a chance to get opened.
  for (i = 0; i < 200; i++) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test installing a signal handler before the Go code starts.
// This is a lot like ../testcshared/main4.c.

#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:
        assertOneCompilerDaemonIsRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("clean", "compileAll")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:

//go:noinline
func f(x *byte, m map[string]*bool) {
	if err := g(x, *m["hello"]); err != nil { // this was miscompiled
		return
	}
}

func main2() {
	m := make(map[string]*bool)
	x := false
	m["hello"] = &x
	b := byte(17)
	f(&b, m)
}

func main() {
	main2()
	main1()

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:
        assertOneCompilerDaemonIsRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("clean", "compileAll")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:

        component.writeSources(file("src/main"))
        component.writeSources(child.file("src/main"))
        settingsFile << """
            include ":child"
        """
    }

    def withSingleProjectSources() {
        component.writeSources(file("src/main"))
        component.writeSources(file("src/main2"))
        buildFile << newSourceSet("main2")
    }

			if x&0xff00 != y&0xff00 {
				t.Errorf("x=%x y=%x\n", x, y)
				done <- false
				return
			}
		}
		done <- true
	}()
	<-done
	<-done
}

func TestDupLoad(t *testing.T) {
	main1(t)
	main2(t)

      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "main"
  op: "_Retval"
  input: "StatefulWhile:1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "main1"
  op: "_Retval"
  input: "StatelessWhile:1"
  attr {
    key: "T"
    value {

            return workResult
        }
    }

    def "deletes output files and according hash directory"() {
        setup:
        sourceFiles = Arrays.asList(tmpDirProvider.file("src/main/c/main.c"), tmpDirProvider.file("src/main/c/foo/main2.c"))
        when:
        compile(sourceFiles[0], sourceFiles[1])
        then:
        outputDir.listFiles().size() == 2

        when:
        compile(sourceFiles[0])
        then:

// license that can be found in the LICENSE file.

// Test that a signal handler that uses up stack space does not crash
// if the signal is delivered to a thread running a goroutine.
// This is a lot like ../testcarchive/main2.c.

#include <setjmp.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sched.h>
#include <time.h>