#cgo LDFLAGS: -fsanitize=thread

int val;

int getVal() {
	return val;
}

void setVal(int i) {
	val = i;
}
*/
import "C"

import (
	"runtime"
)

func main() {
	runtime.LockOSThread()
	C.setVal(1)
	c := make(chan bool)
	go func() {
		runtime.LockOSThread()
		C.setVal(2)
		c <- true
	}()
	<-c
	if v := C.getVal(); v != 2 {
		panic(v)
	}

int run() {
	val = 1;
	GoRun();
	return val;
}

void setVal(int) __attribute__ ((weak));

void setVal(int i) {
	val = i;
}
*/
import "C"

import "runtime"

//export GoRun
func GoRun() {
	runtime.LockOSThread()
	c := make(chan bool)
	go func() {
		runtime.LockOSThread()
		C.setVal(2)
		c <- true
	}()
	<-c
}

func main() {
	if v := C.run(); v != 2 {

    // CHECK-NEXT: tf_executor.fetch %[[control_1]], %[[control_2]], %[[control_3]] : !tf_executor.control, !tf_executor.control, !tf_executor.control
    tf_executor.fetch
  }
  func.return
}

// -----

// Tests one group with multiple branches.
// We expect the following dependency chains after the pass
// A -> B -> fetch, C -> D -> fetch, E -> fetch.
func.func @one_group_multiple_branches() {

    public void normalize(Model model, ModelBuildingRequest request) {
        if (model == null) {
            return;
        }

        model.setUrl(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            scm.setUrl(normalize(scm.getUrl()));
            scm.setConnection(normalize(scm.getConnection()));
            scm.setDeveloperConnection(normalize(scm.getDeveloperConnection()));

  tf_executor.graph {
  }
  func.return

// CHECK:      tf_executor.graph {
// CHECK-NEXT:  tf_executor.fetch
// CHECK-NEXT: }

}

// CHECK-LABEL: func @graph_with_fetch(%{{.*}}: tensor<*xf32>)
func.func @graph_with_fetch(%0: tensor<*xf32>) -> tensor<*xf32> {
  %result = tf_executor.graph {
    tf_executor.fetch %0 : tensor<*xf32>
  }
  func.return %result : tensor<*xf32>
}

      }) {} : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// CHECK:      [[ISLAND_0_CTRL:%.+]] = tf_executor.island {
// CHECK:        tf_executor.yield
// CHECK:      [[ISLAND_1_CTRL:%.+]] = tf_executor.island {
// CHECK:        tf_executor.yield
// CHECK:      tf_executor.fetch [[ISLAND_0_CTRL]], [[ISLAND_1_CTRL]] :


// CHECK-LABEL: func @testDataOperandsAndResults

        "everything has convention and nothing set"        | setAll("convention", "convention") | ""                    | """id = convention\nbar = convention"""
        "everything has convention and is set"             | setAll("convention", "convention") | setAll("test", "baz") | """id = test\nbar = baz"""
    }

    def "sensible error when conventions are set more than once (#testCase)"() {

      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  tf_executor.graph {
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// -----

// Test that functions' graph op must have a single island op and a single fetch
// op, otherwise, the pass will signal failure.

    }
    tf_executor.fetch %2#0 : tensor<f32>
  }
  func.return %0 : tensor<f32>
}

// CHECK:        %[[ISLAND:.*]], %[[ISLAND_control:.*]] = tf_executor.island {
// CHECK-NEXT:     "tf.opA"(%[[ARG_0]])
// CHECK-NEXT:     %[[OP_B:[0-9]*]] = "tf.opB"
// CHECK-NEXT:     tf_executor.yield %[[OP_B]] : tensor<f32>
// CHECK:        tf_executor.fetch %[[ISLAND]] : tensor<f32>

    // CHECK-NOT:  device = "/job:localhost/replica:0/task:0/device:TPU:0"
    %1:2 = tf_executor.island wraps "tf.Identity"(%0#0) : (tensor<i64>) -> tensor<i64>
    tf_executor.fetch %1#1 : !tf_executor.control
  }
  tf_executor.graph {
    tf_executor.fetch
  }
  func.return
}

// CHECK-LABEL: func @testNoGraph
func.func @testNoGraph() -> tensor<i64> {