diff --git a/tests/6.0/taskgraph/test_taskgraph.c b/tests/6.0/taskgraph/test_taskgraph.c
new file mode 100644
index 000000000..f4b703232
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph.c
@@ -0,0 +1,40 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraph():
+// Create a taskgraph
+// Ensures the structured block is executed
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraph(void)
+{
+    int errors = 0;
+    int x = 0;
+    #pragma omp parallel shared(x)
+    {
+        # pragma omp single
+        {
+            # pragma omp taskgraph
+            {
+                ++x;
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, x != 1);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraph());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_heterogeneous.c b/tests/6.0/taskgraph/test_taskgraph_heterogeneous.c
new file mode 100644
index 000000000..b7660d034
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_heterogeneous.c
@@ -0,0 +1,63 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphHeterogeneous():
+// Create a taskgraph, spawns 3 dependent tasks
+//  T1 -> T2 -> T3
+// with (T1, T3) on device, (T2) on host.
+//
+// Ensures that
+//   - the structured block is executed 1 to N times
+//   - 3*N tasks are executed/replayed
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphHeterogeneous(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+
+    # pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph
+                {
+                    ++x;
+
+                    # pragma omp target nowait map(tofrom: y) depend(out: y) shared(y)
+                        ++y;
+
+                    # pragma omp task depend(out: y) shared(y)
+                        ++y;
+
+                    # pragma omp target nowait map(tofrom: y) depend(out: y) shared(y)
+                        ++y;
+                }
+            }
+        }
+    }
+
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 3*N);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphHeterogeneous());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_id.c b/tests/6.0/taskgraph/test_taskgraph_id.c
new file mode 100644
index 000000000..1c6c69516
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_id.c
@@ -0,0 +1,73 @@
+//===-- test_taskgraph_id.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphId():
+// M times, run N taskgraphs constructs with id '0<=i<N' that spawns 3 tasks
+//  T1 -> T2 -> T3
+// Ensure that each taskgraph' structured block executed 1 to M times
+// Ensure that each triplets executed precisely M times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphGraphId(void)
+{
+    int errors = 0;
+
+    # define N 16
+    # define M 16
+
+    int x[N];
+    int y[N];
+    memset(x, 0, sizeof(x));
+    memset(y, 0, sizeof(y));
+
+    # pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int j = 0 ; j < M ; ++j)
+            {
+                for (int i = 0 ; i < N ; ++i)
+                {
+                    # pragma omp taskgraph graph_id(i)
+                    {
+                        ++x[i];
+                        for (int i = 0 ; i < 3 ; ++i)
+                        {
+                            # pragma omp task depend(out: y) shared(y)
+                            {
+                                # pragma omp atomic
+                                    ++y[i];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    for (int i = 0 ; i < N ; ++i)
+    {
+        // each taskgraph strucuted block must have executed 1 to M times
+        OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x[i] && x[i] <= M));
+
+        // each triplets must have executed M times
+        OMPVV_TEST_AND_SET_VERBOSE(errors, y[i] != M);
+    }
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphGraphId());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_if.c b/tests/6.0/taskgraph/test_taskgraph_if.c
new file mode 100644
index 000000000..8226255b9
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_if.c
@@ -0,0 +1,59 @@
+//===-- test_taskgraph_if.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphIf():
+// Call
+//  taskgraph if(0) --> execute taskgraph construct, optionally creating a taskgraph record
+//  taskgraph if(1) --> skip
+//  taskgraph if(2) --> execute taskgraph construct, maybe replay taskgraph
+//                      record, or optionally create a taskgraph record
+// ensures that the structured block is executed 1 or 2 times
+// ensures that tasks are executed twice
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphIf(void)
+{
+    int errors = 0;
+    int x = 0;
+    int y = 0;
+    #pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < 3 ; ++i)
+            {
+                # pragma omp taskgraph if(i != 1)
+                {
+                    ++x;
+
+                    # pragma omp task shared(y)
+                        ++y;
+                }
+            }
+        }
+    }
+
+    // the structured block must have been executed once or twice
+    // (once if creating a taskgraph record, twice if creating no taskgraph record)
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(x == 1 || x == 2));
+
+    // the task must execute precisely twice
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 2);
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphIf());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_nogroup.c b/tests/6.0/taskgraph/test_taskgraph_nogroup.c
new file mode 100644
index 000000000..a57821a66
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_nogroup.c
@@ -0,0 +1,52 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphNoGroup():
+// Run a taskgraph nogroup construct N times,
+// ensures the structured block is executed from 1 to N times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphNoGroup(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+    #pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph nogroup
+                {
+                    ++x;
+                    # pragma omp task shared(y)
+                    {
+                        # pragma omp atomic
+                            ++y;
+                    }
+                }
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != N);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphNoGroup());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_parallel.c b/tests/6.0/taskgraph/test_taskgraph_parallel.c
new file mode 100644
index 000000000..bc83c6328
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_parallel.c
@@ -0,0 +1,60 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphParallel():
+// N times, have 'nthreads' threads call the same taskgraph construct
+//
+// ensure the structured block executed 1 to N times,
+// and the replayable task 'N*nthreads' times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphParallel(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+    int nthreads = -1;
+
+    #pragma omp parallel shared(x, y, nthreads)
+    {
+        # pragma omp single
+        {
+            nthreads = omp_get_num_threads();
+        }
+
+        for (int i = 0 ; i < N ; ++i)
+        {
+            # pragma omp taskgraph
+            {
+                ++x;
+                # pragma omp task shared(y)
+                {
+                    # pragma omp atomic
+                        ++y;
+                }
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, nthreads <= 0);
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != nthreads*N);
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphParallel());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_replay.c b/tests/6.0/taskgraph/test_taskgraph_replay.c
new file mode 100644
index 000000000..0d66d12dd
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_replay.c
@@ -0,0 +1,58 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphReplay():
+// N times, run a taskgraph construct spawning M tasks
+// Ensures that the structured block is executed one to N times
+// Ensures that the tasks structured block is executed M*N times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphReplay(void)
+{
+    int errors = 0;
+    # define N 16
+    # define M 16
+
+    int x = 0;
+    int y = 0;
+
+    #pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph
+                {
+                    ++x;
+                    for (int j = 0 ; j < M ; ++j)
+                    {
+                        # pragma omp task shared(y)
+                        {
+                            # pragma omp atomic
+                            ++y;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != M*N);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphReplay());
+    OMPVV_REPORT_AND_RETURN(errors);
+}
diff --git a/tests/6.0/taskgraph/test_taskgraph_reset.c b/tests/6.0/taskgraph/test_taskgraph_reset.c
new file mode 100644
index 000000000..1f632f60a
--- /dev/null
+++ b/tests/6.0/taskgraph/test_taskgraph_reset.c
@@ -0,0 +1,71 @@
+//===-- test_taskgraph_reset.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphGraphReset():
+// Run the same taskgraph constructs N times, that spawns 3 tasks
+//  T1 -> T2 -> T3
+// with (T1, T3) on device, (T2) on host.
+// while reseting every second iterations.
+//
+// Ensures that structured block executed N/2 to N times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphGraphReset(void)
+{
+    int errors = 0;
+
+    # define N 16
+    _Static_assert(N % 2 == 0, "N must be even");
+
+    int x = 0;
+    int y = 0;
+
+    # pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph graph_reset(i % 2 == 0)
+                {
+                    # pragma omp atomic
+                        ++x;
+
+                    for (int i = 0 ; i < 3 ; ++i)
+                    {
+                        # pragma omp task depend(out: y) shared(y)
+                        {
+                            # pragma omp atomic
+                                ++y;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // taskgraph structured block must have executed at least N/2 times (is
+    // always creating a taskgraph record), and at most N times (if never
+    // creating a taskgraph record)
+    OMPVV_TEST_AND_SET_VERBOSE(errors, (N/2 <= x && x <= N));
+
+    // each triplets must have executed N times
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 3*N);
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphGraphReset());
+    OMPVV_REPORT_AND_RETURN(errors);
+}