func TestCflags(t *testing.T)                { testCflags(t) }
func TestCheckConst(t *testing.T)            { testCheckConst(t) }
func TestConst(t *testing.T)                 { testConst(t) }
func TestCthread(t *testing.T)               { testCthread(t) }
func TestEnum(t *testing.T)                  { testEnum(t) }
func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }

 * limitations under the License.
 */

package org.gradle.test.fixtures.concurrent

/**
 * Represents the current thread.
 */
class TestThread {
    private final Instants instants

    TestThread(Instants instants) {
        this.instants = instants
    }

    void block() {
        Thread.sleep(750)
    }

    BlockTarget getBlockUntil() {

    monitor = new Monitor(fair);
    tearDownStack.addTearDown(thread1 = new TestThread<>(monitor, "TestThread #1"));
    tearDownStack.addTearDown(thread2 = new TestThread<>(monitor, "TestThread #2"));
  }

  @Override
  protected final void tearDown() {
    tearDownStack.runTearDown();
  }

  private String enter() {
    return interruptible ? "enterInterruptibly" : "enter";
  }

    monitor = new Monitor(fair);
    tearDownStack.addTearDown(thread1 = new TestThread<>(monitor, "TestThread #1"));
    tearDownStack.addTearDown(thread2 = new TestThread<>(monitor, "TestThread #2"));
  }

  @Override
  protected final void tearDown() {
    tearDownStack.runTearDown();
  }

  private String enter() {
    return interruptible ? "enterInterruptibly" : "enter";
  }

        def actor = factory.createBlockingActor(target)
        def testThread = Thread.currentThread()

        when:
        actor.dispatch(new MethodInvocation(TargetObject.class.getMethod('doStuff', String.class), ['param'] as Object[]))

        then:
        1 * target.doStuff('param') >> {
            assert Thread.currentThread() == testThread
        }
    }

     *
     * @see NamedOperation
     */
    final Operations operation = new Operations(instant, instant)

    /**
     * An object that allows control over the current thread.
     */
    final TestThread thread = new TestThread(instant)

    final BlockTarget waitFor = new BlockTarget(instant)

    public final TestExecutor executor = new TestExecutor(logger)

    val closedRequestBody = assertOnFileDescriptor { it.toRequestBody() }

    assertThrows(IOException::class.java) {
      closedRequestBody.writeTo(Buffer())
    }
  }

  @Test
  fun testPathRead() {
    assertOnPath(content = "Hello") { path ->
      val requestBody = path.asRequestBody(FileSystem.SYSTEM)

      val buffer = Buffer()
      requestBody.writeTo(buffer)

void SomeThreadFunc(void* data) {
  auto* real_data = static_cast<SomeThreadData*>(data);
  ::tensorflow::mutex_lock l(real_data->mu);
  real_data->did_work = true;
}

}  // namespace

TEST(TestEnv, TestThreads) {
  TF_ThreadOptions options;
  TF_DefaultThreadOptions(&options);
  SomeThreadData data;
  TF_Thread* thread =
      TF_StartThread(&options, "SomeThreadName", &SomeThreadFunc, &data);
  TF_JoinThread(thread);