[flang-commits] [flang] [llvm] Add print statements to lit for tracing purposes (PR #92694)

Vlad Serebrennikov via flang-commits flang-commits at lists.llvm.org
Sun May 19 12:40:37 PDT 2024


https://github.com/Endilll updated https://github.com/llvm/llvm-project/pull/92694

>From 2d419dd0910260272fea457beb59414798ee2594 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 15:54:44 +0300
Subject: [PATCH 01/11] Add print statements to lit for tracing purposes

---
 llvm/utils/lit/lit/main.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/llvm/utils/lit/lit/main.py b/llvm/utils/lit/lit/main.py
index db9f24f748d9e..288558b90b77a 100755
--- a/llvm/utils/lit/lit/main.py
+++ b/llvm/utils/lit/lit/main.py
@@ -118,34 +118,56 @@ def main(builtin_params={}):
 
     mark_xfail(discovered_tests, opts)
 
+    print("Endill 10")
+
     mark_excluded(discovered_tests, selected_tests)
 
+    print("Endill 20")
+
     start = time.time()
+    print("Endill 30")
     run_tests(selected_tests, lit_config, opts, len(discovered_tests))
+    print("Endill 40")
     elapsed = time.time() - start
 
+    print("Endill 50")
+
     record_test_times(selected_tests, lit_config)
 
+    print("Endill 60")
+
     selected_tests, discovered_tests = GoogleTest.post_process_shard_results(
         selected_tests, discovered_tests
     )
 
+    print("Endill 70")
+
     if opts.time_tests:
         print_histogram(discovered_tests)
 
+    print("Endill 80")
+
     print_results(discovered_tests, elapsed, opts)
 
+    print("Endill 90")
+
     tests_for_report = selected_tests if opts.shard else discovered_tests
     for report in opts.reports:
         report.write_results(tests_for_report, elapsed)
 
+    print("Endill 100")
+
     if lit_config.numErrors:
         sys.stderr.write("\n%d error(s) in tests\n" % lit_config.numErrors)
         sys.exit(2)
+    
+    print("Endill 110")
 
     if lit_config.numWarnings:
         sys.stderr.write("\n%d warning(s) in tests\n" % lit_config.numWarnings)
 
+    print("Endill 120")
+
     has_failure = any(t.isFailure() for t in discovered_tests)
     if has_failure:
         if opts.ignoreFail:

>From 7edeaee2dfa50586406f27609bbd55d75e590aef Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 17:12:16 +0300
Subject: [PATCH 02/11] Add more tracing

---
 llvm/utils/lit/lit/main.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/llvm/utils/lit/lit/main.py b/llvm/utils/lit/lit/main.py
index 288558b90b77a..91e9d2310e52f 100755
--- a/llvm/utils/lit/lit/main.py
+++ b/llvm/utils/lit/lit/main.py
@@ -266,19 +266,23 @@ def mark_excluded(discovered_tests, selected_tests):
 
 
 def run_tests(tests, lit_config, opts, discovered_tests):
+    print("Endill 310")
     workers = min(len(tests), opts.workers)
+    print("Endill 320")
     display = lit.display.create_display(opts, tests, discovered_tests, workers)
-
+    print("Endill 330")
     run = lit.run.Run(
         tests, lit_config, workers, display.update, opts.max_failures, opts.timeout
     )
-
+    print("Endill 340")
     display.print_header()
-
+    print("Endill 350")
     interrupted = False
     error = None
     try:
+        print("Endill 360")
         execute_in_tmp_dir(run, lit_config)
+        print("Endill 370")
     except KeyboardInterrupt:
         interrupted = True
         error = "  interrupted by user"
@@ -286,10 +290,13 @@ def run_tests(tests, lit_config, opts, discovered_tests):
         error = "warning: reached maximum number of test failures"
     except lit.run.TimeoutError:
         error = "warning: reached timeout"
+    print("Endill 380")
 
     display.clear(interrupted)
+        print("Endill 390")
     if error:
         sys.stderr.write("%s, skipping remaining tests\n" % error)
+    print("Endill 3100")
 
 
 def execute_in_tmp_dir(run, lit_config):

>From 13a86f1060c84e82bfbb925e16f5985907b29dd0 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 17:12:45 +0300
Subject: [PATCH 03/11] Fix indentation

---
 llvm/utils/lit/lit/main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/llvm/utils/lit/lit/main.py b/llvm/utils/lit/lit/main.py
index 91e9d2310e52f..ee991f5360a4d 100755
--- a/llvm/utils/lit/lit/main.py
+++ b/llvm/utils/lit/lit/main.py
@@ -293,7 +293,7 @@ def run_tests(tests, lit_config, opts, discovered_tests):
     print("Endill 380")
 
     display.clear(interrupted)
-        print("Endill 390")
+    print("Endill 390")
     if error:
         sys.stderr.write("%s, skipping remaining tests\n" % error)
     print("Endill 3100")

>From 34619d6b865645e30af729aed03ff2d35a974062 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 17:16:15 +0300
Subject: [PATCH 04/11] Add even more tracing

---
 llvm/utils/lit/lit/main.py | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/llvm/utils/lit/lit/main.py b/llvm/utils/lit/lit/main.py
index ee991f5360a4d..09354b3092d8a 100755
--- a/llvm/utils/lit/lit/main.py
+++ b/llvm/utils/lit/lit/main.py
@@ -300,6 +300,7 @@ def run_tests(tests, lit_config, opts, discovered_tests):
 
 
 def execute_in_tmp_dir(run, lit_config):
+    print("Endill 3600")
     # Create a temp directory inside the normal temp directory so that we can
     # try to avoid temporary test file leaks. The user can avoid this behavior
     # by setting LIT_PRESERVES_TMP in the environment, so they can easily use
@@ -308,26 +309,36 @@ def execute_in_tmp_dir(run, lit_config):
     tmp_dir = None
     if "LIT_PRESERVES_TMP" not in os.environ:
         import tempfile
-
+        print("Endill 3610")
         # z/OS linker does not support '_' in paths, so use '-'.
         tmp_dir = tempfile.mkdtemp(prefix="lit-tmp-")
+        print("Endill 3620")
         tmp_dir_envs = {k: tmp_dir for k in ["TMP", "TMPDIR", "TEMP", "TEMPDIR"]}
         os.environ.update(tmp_dir_envs)
+        print("Endill 3630")
         for cfg in {t.config for t in run.tests}:
             cfg.environment.update(tmp_dir_envs)
+        print("Endill 3640")
     try:
+        print("Endill 3650")
         run.execute()
+        print("Endill 3660")
     finally:
+        print("Endill 3670")
         if tmp_dir:
             try:
+                print("Endill 3680")
                 import shutil
-
+                print("Endill 3690") 
                 shutil.rmtree(tmp_dir)
+                print("Endill 36100") 
             except Exception as e:
+                print("Endill 36110") 
                 lit_config.warning(
                     "Failed to delete temp directory '%s', try upgrading your version of Python to fix this"
                     % tmp_dir
                 )
+    print("Endill 36120")
 
 
 def print_histogram(tests):

>From bc6d8fd4a834a2a48fb450e1627680f36a35e066 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 18:17:34 +0300
Subject: [PATCH 05/11] Add even more tracing

---
 llvm/utils/lit/lit/formats/googletest.py | 11 ++++++++--
 llvm/utils/lit/lit/run.py                | 28 ++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/llvm/utils/lit/lit/formats/googletest.py b/llvm/utils/lit/lit/formats/googletest.py
index 8037094a91067..25dcc85df81e4 100644
--- a/llvm/utils/lit/lit/formats/googletest.py
+++ b/llvm/utils/lit/lit/formats/googletest.py
@@ -140,18 +140,20 @@ def getTestsInDirectory(self, testSuite, path_in_suite, litConfig, localConfig):
                     )
 
     def execute(self, test, litConfig):
+        print("Endill gt-0")
         if test.gtest_json_file is None:
             return lit.Test.FAIL, ""
 
         testPath = test.getSourcePath()
         from lit.cl_arguments import TestOrder
-
+        print("Endill gt-1")
         use_shuffle = TestOrder(litConfig.order) == TestOrder.RANDOM
         shard_env = {
             "GTEST_OUTPUT": "json:" + test.gtest_json_file,
             "GTEST_SHUFFLE": "1" if use_shuffle else "0",
         }
         if litConfig.gtest_sharding:
+            print("Endill gt-2")
             testPath, testName = os.path.split(test.getSourcePath())
             while not os.path.exists(testPath):
                 # Handle GTest parameterized and typed tests, whose name includes
@@ -186,13 +188,16 @@ def get_shard_header(shard_env):
         shard_header = get_shard_header(shard_env)
 
         try:
+            print("Endill gt-3")
             out, _, exitCode = lit.util.executeCommand(
                 cmd,
                 env=test.config.environment,
                 timeout=litConfig.maxIndividualTestTime,
                 redirect_stderr=True,
             )
+            print("Endill gt-4")
         except lit.util.ExecuteCommandTimeoutException as e:
+            print("Endill gt-5")
             stream_msg = f"\n{e.out}\n--\nexit: {e.exitCode}\n--\n"
             return (
                 lit.Test.TIMEOUT,
@@ -225,7 +230,9 @@ def get_test_stdout(test_name):
         found_failed_test = False
 
         with open(test.gtest_json_file, encoding="utf-8") as f:
+            print("Endill gt-6")
             jf = json.load(f)
+            print("Endill gt-7")
 
             if use_shuffle:
                 shard_env["GTEST_RANDOM_SEED"] = str(jf["random_seed"])
@@ -258,7 +265,7 @@ def get_test_stdout(test_name):
         # the shard could still fail due to memory issues.
         if not found_failed_test:
             output += f"\n{out}\n--\nexit: {exitCode}\n--\n"
-
+        print("Endill gt-8")
         return lit.Test.FAIL, output
 
     def prepareCmd(self, cmd):
diff --git a/llvm/utils/lit/lit/run.py b/llvm/utils/lit/lit/run.py
index 535c859352cc4..ebbce0e75a9ce 100644
--- a/llvm/utils/lit/lit/run.py
+++ b/llvm/utils/lit/lit/run.py
@@ -30,6 +30,7 @@ def __init__(
         assert workers > 0
 
     def execute(self):
+        print("Endill 36500")
         """
         Execute the tests in the run using up to the specified number of
         parallel tasks, and inform the caller of each individual result. The
@@ -55,25 +56,36 @@ def execute(self):
         deadline = time.time() + timeout
 
         try:
+            print("Endill 36510")
             self._execute(deadline)
+            print("Endill 36520")
         finally:
+            print("Endill 36530")
             skipped = lit.Test.Result(lit.Test.SKIPPED)
+            print("Endill 36540")
             for test in self.tests:
+                print("Endill 36550")
                 if test.result is None:
                     test.setResult(skipped)
+            print("Endill 36560")
+            
 
     def _execute(self, deadline):
+        print("Endill 365100")
         self._increase_process_limit()
+        print("Endill 365110")
 
         semaphores = {
             k: multiprocessing.BoundedSemaphore(v)
             for k, v in self.lit_config.parallelism_groups.items()
             if v is not None
         }
+        print("Endill 365120")
 
         pool = multiprocessing.Pool(
             self.workers, lit.worker.initialize, (self.lit_config, semaphores)
         )
+        print("Endill 365130")
 
         async_results = [
             pool.apply_async(
@@ -81,29 +93,45 @@ def _execute(self, deadline):
             )
             for test in self.tests
         ]
+        print("Endill 365140")
         pool.close()
+        print("Endill 365150")
 
         try:
+            print("Endill 365160")
             self._wait_for(async_results, deadline)
+            print("Endill 365170")
         except:
+            print("Endill 365180")
             pool.terminate()
+            print("Endill 365190")
             raise
         finally:
+            print("Endill 3651100")
             pool.join()
+            print("Endill 3651110")
 
     def _wait_for(self, async_results, deadline):
+        print("Endill 3651600")
         timeout = deadline - time.time()
         for idx, ar in enumerate(async_results):
+            print("Endill 3651610")
             try:
+                print("Endill 3651620")
                 test = ar.get(timeout)
+                print("Endill 3651630")
             except multiprocessing.TimeoutError:
+                print("Endill 3651640")
                 raise TimeoutError()
             else:
+                print("Endill 3651650")
                 self._update_test(self.tests[idx], test)
+                print("Endill 3651660")
                 if test.isFailure():
                     self.failures += 1
                     if self.failures == self.max_failures:
                         raise MaxFailuresError()
+        print("Endill 3651670") 
 
     # Update local test object "in place" from remote test object.  This
     # ensures that the original test object which is used for printing test

>From e6256b3019b721077847c23b648d0b98eb2fe872 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 19:20:13 +0300
Subject: [PATCH 06/11] Print individual test details

---
 llvm/utils/lit/lit/formats/googletest.py | 4 ++++
 llvm/utils/lit/lit/run.py                | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/llvm/utils/lit/lit/formats/googletest.py b/llvm/utils/lit/lit/formats/googletest.py
index 25dcc85df81e4..a054e044beff9 100644
--- a/llvm/utils/lit/lit/formats/googletest.py
+++ b/llvm/utils/lit/lit/formats/googletest.py
@@ -205,12 +205,15 @@ def get_shard_header(shard_env):
                 f"timeout of {litConfig.maxIndividualTestTime} seconds",
             )
 
+        print("Endill gt-5-1")
         if not os.path.exists(test.gtest_json_file):
+            print("Endill gt-5-2")
             errmsg = f"shard JSON output does not exist: %s" % (test.gtest_json_file)
             stream_msg = f"\n{out}\n--\nexit: {exitCode}\n--\n"
             return lit.Test.FAIL, shard_header + stream_msg + errmsg
 
         if exitCode == 0:
+            print("Endill gt-5-3")
             return lit.Test.PASS, ""
 
         def get_test_stdout(test_name):
@@ -229,6 +232,7 @@ def get_test_stdout(test_name):
 
         found_failed_test = False
 
+        print("Endill gt-5-4")
         with open(test.gtest_json_file, encoding="utf-8") as f:
             print("Endill gt-6")
             jf = json.load(f)
diff --git a/llvm/utils/lit/lit/run.py b/llvm/utils/lit/lit/run.py
index ebbce0e75a9ce..54482071a67b2 100644
--- a/llvm/utils/lit/lit/run.py
+++ b/llvm/utils/lit/lit/run.py
@@ -64,7 +64,6 @@ def execute(self):
             skipped = lit.Test.Result(lit.Test.SKIPPED)
             print("Endill 36540")
             for test in self.tests:
-                print("Endill 36550")
                 if test.result is None:
                     test.setResult(skipped)
             print("Endill 36560")
@@ -120,6 +119,9 @@ def _wait_for(self, async_results, deadline):
                 print("Endill 3651620")
                 test = ar.get(timeout)
                 print("Endill 3651630")
+                print("Endill: test.file_path: {}".format(test.file_path))
+                print("Endill: test.path_in_suite: {}".format(test.path_in_suite))
+                print("Endill 3651635")
             except multiprocessing.TimeoutError:
                 print("Endill 3651640")
                 raise TimeoutError()

>From 15fc2f17fbb6aa4b1500f713ea00540b2b70df53 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 20:27:31 +0300
Subject: [PATCH 07/11] Print names of unit tests in shards

---
 llvm/utils/lit/lit/formats/googletest.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/llvm/utils/lit/lit/formats/googletest.py b/llvm/utils/lit/lit/formats/googletest.py
index a054e044beff9..e665ac6a98cae 100644
--- a/llvm/utils/lit/lit/formats/googletest.py
+++ b/llvm/utils/lit/lit/formats/googletest.py
@@ -214,6 +214,16 @@ def get_shard_header(shard_env):
 
         if exitCode == 0:
             print("Endill gt-5-3")
+            print("Endill: shard header: {}".format(get_shard_header(shard_env)))
+            with open(test.gtest_json_file, encoding="utf-8") as f:
+                print("Endill gt-5-6")
+                jf = json.load(f)
+                print("Endill gt-5-7")
+                for testcase in jf["testsuites"]:
+                    for testinfo in testcase["testsuite"]:
+                        testname = testcase["name"] + "." + testinfo["name"]
+                        print("Endill: testnamae: {}".format(testname))
+
             return lit.Test.PASS, ""
 
         def get_test_stdout(test_name):

>From 1c785a63d029dc55fc06ec236e55983729767e2f Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 21:30:55 +0300
Subject: [PATCH 08/11] Disable a bunch of flang tests

---
 .../Optimizer/Builder/ComplexTest.cpp         |  44 ++--
 .../Optimizer/Builder/DoLoopHelperTest.cpp    |  30 +--
 .../Optimizer/Builder/FIRBuilderTest.cpp      |  12 +-
 .../Optimizer/Builder/HLFIRToolsTest.cpp      |  64 +++---
 .../Builder/Runtime/CharacterTest.cpp         |  22 +-
 .../Optimizer/Builder/Runtime/CommandTest.cpp |  12 +-
 .../Builder/Runtime/ReductionTest.cpp         |  42 ++--
 flang/unittests/Optimizer/FIRTypesTest.cpp    |  54 ++---
 .../Optimizer/FortranVariableTest.cpp         |  44 ++--
 .../unittests/Optimizer/InternalNamesTest.cpp |  64 +++---
 flang/unittests/Runtime/CharacterTest.cpp     |  96 ++++-----
 flang/unittests/Runtime/CommandTest.cpp       |  74 +++----
 flang/unittests/Runtime/Complex.cpp           |  34 +--
 flang/unittests/Runtime/ExternalIOTest.cpp    | 194 +++++++++---------
 flang/unittests/Runtime/Format.cpp            |  24 +--
 flang/unittests/Runtime/ListInputTest.cpp     |  58 +++---
 flang/unittests/Runtime/MiscIntrinsic.cpp     |  36 ++--
 flang/unittests/Runtime/Numeric.cpp           | 120 +++++------
 .../unittests/Runtime/NumericalFormatTest.cpp |  30 +--
 flang/unittests/Runtime/Pointer.cpp           |  38 ++--
 flang/unittests/Runtime/RuntimeCrashTest.cpp  |  18 +-
 flang/unittests/Runtime/Stop.cpp              |  36 ++--
 flang/unittests/Runtime/TemporaryStack.cpp    | 160 +++++++--------
 23 files changed, 653 insertions(+), 653 deletions(-)

diff --git a/flang/unittests/Optimizer/Builder/ComplexTest.cpp b/flang/unittests/Optimizer/Builder/ComplexTest.cpp
index 17171512470ac..b17ef9ef2f348 100644
--- a/flang/unittests/Optimizer/Builder/ComplexTest.cpp
+++ b/flang/unittests/Optimizer/Builder/ComplexTest.cpp
@@ -62,30 +62,30 @@ struct ComplexTest : public testing::Test {
   mlir::Value rFour;
 };
 
-TEST_F(ComplexTest, verifyTypes) {
-  mlir::Value cVal1 = helper->createComplex(complexTy1, rOne, rTwo);
-  mlir::Value cVal2 = helper->createComplex(4, rOne, rTwo);
-  EXPECT_TRUE(fir::isa_complex(cVal1.getType()));
-  EXPECT_TRUE(fir::isa_complex(cVal2.getType()));
-  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal1)));
-  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal2)));
+// TEST_F(ComplexTest, verifyTypes) {
+//   mlir::Value cVal1 = helper->createComplex(complexTy1, rOne, rTwo);
+//   mlir::Value cVal2 = helper->createComplex(4, rOne, rTwo);
+//   EXPECT_TRUE(fir::isa_complex(cVal1.getType()));
+//   EXPECT_TRUE(fir::isa_complex(cVal2.getType()));
+//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal1)));
+//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal2)));
 
-  mlir::Value real1 = helper->extractComplexPart(cVal1, /*isImagPart=*/false);
-  mlir::Value imag1 = helper->extractComplexPart(cVal1, /*isImagPart=*/true);
-  mlir::Value real2 = helper->extractComplexPart(cVal2, /*isImagPart=*/false);
-  mlir::Value imag2 = helper->extractComplexPart(cVal2, /*isImagPart=*/true);
-  EXPECT_EQ(realTy1, real1.getType());
-  EXPECT_EQ(realTy1, imag1.getType());
-  EXPECT_EQ(realTy1, real2.getType());
-  EXPECT_EQ(realTy1, imag2.getType());
+//   mlir::Value real1 = helper->extractComplexPart(cVal1, /*isImagPart=*/false);
+//   mlir::Value imag1 = helper->extractComplexPart(cVal1, /*isImagPart=*/true);
+//   mlir::Value real2 = helper->extractComplexPart(cVal2, /*isImagPart=*/false);
+//   mlir::Value imag2 = helper->extractComplexPart(cVal2, /*isImagPart=*/true);
+//   EXPECT_EQ(realTy1, real1.getType());
+//   EXPECT_EQ(realTy1, imag1.getType());
+//   EXPECT_EQ(realTy1, real2.getType());
+//   EXPECT_EQ(realTy1, imag2.getType());
 
-  mlir::Value cVal3 =
-      helper->insertComplexPart(cVal1, rThree, /*isImagPart=*/false);
-  mlir::Value cVal4 =
-      helper->insertComplexPart(cVal3, rFour, /*isImagPart=*/true);
-  EXPECT_TRUE(fir::isa_complex(cVal4.getType()));
-  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal4)));
-}
+//   mlir::Value cVal3 =
+//       helper->insertComplexPart(cVal1, rThree, /*isImagPart=*/false);
+//   mlir::Value cVal4 =
+//       helper->insertComplexPart(cVal3, rFour, /*isImagPart=*/true);
+//   EXPECT_TRUE(fir::isa_complex(cVal4.getType()));
+//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal4)));
+// }
 
 TEST_F(ComplexTest, verifyConvertWithSemantics) {
   auto loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp b/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
index d0a9342914a39..9da6cde3e1d1e 100644
--- a/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
+++ b/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
@@ -69,19 +69,19 @@ TEST_F(DoLoopHelperTest, createLoopWithLowerAndUpperBound) {
   checkConstantValue(loop.getStep(), 1);
 }
 
-TEST_F(DoLoopHelperTest, createLoopWithStep) {
-  auto firBuilder = getBuilder();
-  fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
+// TEST_F(DoLoopHelperTest, createLoopWithStep) {
+//   auto firBuilder = getBuilder();
+//   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 
-  auto lb = firBuilder.createIntegerConstant(
-      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
-  auto ub = firBuilder.createIntegerConstant(
-      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
-  auto step = firBuilder.createIntegerConstant(
-      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 2);
-  auto loop = helper.createLoop(
-      lb, ub, step, [&](fir::FirOpBuilder &, mlir::Value index) {});
-  checkConstantValue(loop.getLowerBound(), 1);
-  checkConstantValue(loop.getUpperBound(), 20);
-  checkConstantValue(loop.getStep(), 2);
-}
+//   auto lb = firBuilder.createIntegerConstant(
+//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
+//   auto ub = firBuilder.createIntegerConstant(
+//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
+//   auto step = firBuilder.createIntegerConstant(
+//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 2);
+//   auto loop = helper.createLoop(
+//       lb, ub, step, [&](fir::FirOpBuilder &, mlir::Value index) {});
+//   checkConstantValue(loop.getLowerBound(), 1);
+//   checkConstantValue(loop.getUpperBound(), 20);
+//   checkConstantValue(loop.getStep(), 2);
+// }
diff --git a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
index e5e5454ee88ad..3f18ea073711f 100644
--- a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
+++ b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
@@ -154,12 +154,12 @@ TEST_F(FIRBuilderTest, createRealZeroConstant) {
       0u, mlir::cast<FloatAttr>(cstOp.getValue()).getValue().convertToDouble());
 }
 
-TEST_F(FIRBuilderTest, createBool) {
-  auto builder = getBuilder();
-  auto loc = builder.getUnknownLoc();
-  auto b = builder.createBool(loc, false);
-  checkIntegerConstant(b, builder.getIntegerType(1), 0);
-}
+// TEST_F(FIRBuilderTest, createBool) {
+//   auto builder = getBuilder();
+//   auto loc = builder.getUnknownLoc();
+//   auto b = builder.createBool(loc, false);
+//   checkIntegerConstant(b, builder.getIntegerType(1), 0);
+// }
 
 TEST_F(FIRBuilderTest, getVarLenSeqTy) {
   auto builder = getBuilder();
diff --git a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
index 1858b276f1fc3..616045f275e16 100644
--- a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
+++ b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
@@ -126,38 +126,38 @@ TEST_F(HLFIRToolsTest, testScalarCharRoundTrip) {
   EXPECT_FALSE(scalarCharEntity.isValue());
 }
 
-TEST_F(HLFIRToolsTest, testArrayCharRoundTrip) {
-  auto &builder = getBuilder();
-  mlir::Location loc = getLoc();
-  llvm::SmallVector<mlir::Value> extents{
-      createConstant(20), createConstant(30)};
-  llvm::SmallVector<mlir::Value> lbounds{
-      createConstant(-1), createConstant(-2)};
-  mlir::Value len = createConstant(42);
-  mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
-  mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
-  mlir::Type arrayCharType = builder.getRefType(seqCharType);
-  mlir::Value arrayCharAddr = builder.create<fir::UndefOp>(loc, arrayCharType);
-  fir::CharArrayBoxValue arrayChar{arrayCharAddr, len, extents, lbounds};
-  hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
-  auto [arrayCharResult, cleanup] =
-      hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
-  auto *res = arrayCharResult.getBoxOf<fir::CharArrayBoxValue>();
-  EXPECT_FALSE(cleanup.has_value());
-  ASSERT_NE(res, nullptr);
-  // gtest has a terrible time printing mlir::Value in case of failing
-  // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
-  EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getFirBase());
-  EXPECT_TRUE(res->getLen() == arrayChar.getLen());
-  ASSERT_EQ(res->getExtents().size(), arrayChar.getExtents().size());
-  for (unsigned i = 0; i < arrayChar.getExtents().size(); ++i)
-    EXPECT_TRUE(res->getExtents()[i] == arrayChar.getExtents()[i]);
-  ASSERT_EQ(res->getLBounds().size(), arrayChar.getLBounds().size());
-  for (unsigned i = 0; i < arrayChar.getLBounds().size(); ++i)
-    EXPECT_TRUE(res->getLBounds()[i] == arrayChar.getLBounds()[i]);
-  EXPECT_TRUE(arrayCharEntity.isVariable());
-  EXPECT_FALSE(arrayCharEntity.isValue());
-}
+// TEST_F(HLFIRToolsTest, testArrayCharRoundTrip) {
+//   auto &builder = getBuilder();
+//   mlir::Location loc = getLoc();
+//   llvm::SmallVector<mlir::Value> extents{
+//       createConstant(20), createConstant(30)};
+//   llvm::SmallVector<mlir::Value> lbounds{
+//       createConstant(-1), createConstant(-2)};
+//   mlir::Value len = createConstant(42);
+//   mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
+//   mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
+//   mlir::Type arrayCharType = builder.getRefType(seqCharType);
+//   mlir::Value arrayCharAddr = builder.create<fir::UndefOp>(loc, arrayCharType);
+//   fir::CharArrayBoxValue arrayChar{arrayCharAddr, len, extents, lbounds};
+//   hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
+//   auto [arrayCharResult, cleanup] =
+//       hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
+//   auto *res = arrayCharResult.getBoxOf<fir::CharArrayBoxValue>();
+//   EXPECT_FALSE(cleanup.has_value());
+//   ASSERT_NE(res, nullptr);
+//   // gtest has a terrible time printing mlir::Value in case of failing
+//   // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
+//   EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getFirBase());
+//   EXPECT_TRUE(res->getLen() == arrayChar.getLen());
+//   ASSERT_EQ(res->getExtents().size(), arrayChar.getExtents().size());
+//   for (unsigned i = 0; i < arrayChar.getExtents().size(); ++i)
+//     EXPECT_TRUE(res->getExtents()[i] == arrayChar.getExtents()[i]);
+//   ASSERT_EQ(res->getLBounds().size(), arrayChar.getLBounds().size());
+//   for (unsigned i = 0; i < arrayChar.getLBounds().size(); ++i)
+//     EXPECT_TRUE(res->getLBounds()[i] == arrayChar.getLBounds()[i]);
+//   EXPECT_TRUE(arrayCharEntity.isVariable());
+//   EXPECT_FALSE(arrayCharEntity.isValue());
+// }
 
 TEST_F(HLFIRToolsTest, testArrayCharBoxRoundTrip) {
   auto &builder = getBuilder();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
index 315f8c80dc33f..18f7dd0743a73 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
@@ -113,17 +113,17 @@ TEST_F(RuntimeCallTest, genIndexTest) {
   checkGenIndex(*firBuilder, "_FortranAIndex4", 4);
 }
 
-TEST_F(RuntimeCallTest, genIndexDescriptorTest) {
-  auto loc = firBuilder->getUnknownLoc();
-  mlir::Value resultBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-  mlir::Value stringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-  mlir::Value substringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-  mlir::Value backOpt = firBuilder->create<fir::UndefOp>(loc, boxTy);
-  mlir::Value kind = firBuilder->create<fir::UndefOp>(loc, i32Ty);
-  fir::runtime::genIndexDescriptor(
-      *firBuilder, loc, resultBox, stringBox, substringBox, backOpt, kind);
-  checkCallOpFromResultBox(resultBox, "_FortranAIndex", 5);
-}
+// TEST_F(RuntimeCallTest, genIndexDescriptorTest) {
+//   auto loc = firBuilder->getUnknownLoc();
+//   mlir::Value resultBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+//   mlir::Value stringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+//   mlir::Value substringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+//   mlir::Value backOpt = firBuilder->create<fir::UndefOp>(loc, boxTy);
+//   mlir::Value kind = firBuilder->create<fir::UndefOp>(loc, i32Ty);
+//   fir::runtime::genIndexDescriptor(
+//       *firBuilder, loc, resultBox, stringBox, substringBox, backOpt, kind);
+//   checkCallOpFromResultBox(resultBox, "_FortranAIndex", 5);
+// }
 
 TEST_F(RuntimeCallTest, genRepeatTest) {
   auto loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
index 58a151447d5b4..57347e56b4c61 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
@@ -10,12 +10,12 @@
 #include "RuntimeCallTestBase.h"
 #include "gtest/gtest.h"
 
-TEST_F(RuntimeCallTest, genCommandArgumentCountTest) {
-  mlir::Location loc = firBuilder->getUnknownLoc();
-  mlir::Value result = fir::runtime::genCommandArgumentCount(*firBuilder, loc);
-  checkCallOp(result.getDefiningOp(), "_FortranAArgumentCount", /*nbArgs=*/0,
-      /*addLocArgs=*/false);
-}
+// TEST_F(RuntimeCallTest, genCommandArgumentCountTest) {
+//   mlir::Location loc = firBuilder->getUnknownLoc();
+//   mlir::Value result = fir::runtime::genCommandArgumentCount(*firBuilder, loc);
+//   checkCallOp(result.getDefiningOp(), "_FortranAArgumentCount", /*nbArgs=*/0,
+//       /*addLocArgs=*/false);
+// }
 
 TEST_F(RuntimeCallTest, genGetCommandArgument) {
   mlir::Location loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
index a4006c6b59c12..994e113da70e4 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
@@ -52,15 +52,15 @@ TEST_F(RuntimeCallTest, genCountTest) {
   checkCallOp(count.getDefiningOp(), "_FortranACount", 2);
 }
 
-TEST_F(RuntimeCallTest, genCountDimTest) {
-  mlir::Location loc = firBuilder->getUnknownLoc();
-  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-  mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-  fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
-  checkCallOpFromResultBox(result, "_FortranACountDim", 4);
-}
+// TEST_F(RuntimeCallTest, genCountDimTest) {
+//   mlir::Location loc = firBuilder->getUnknownLoc();
+//   mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+//   mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+//   mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+//   mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+//   fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
+//   checkCallOpFromResultBox(result, "_FortranACountDim", 4);
+// }
 
 void testGenMaxVal(
     fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
@@ -120,14 +120,14 @@ TEST_F(RuntimeCallTest, genParityTest) {
   checkCallOp(parity.getDefiningOp(), "_FortranAParity", 2);
 }
 
-TEST_F(RuntimeCallTest, genParityDescriptorTest) {
-  mlir::Location loc = firBuilder->getUnknownLoc();
-  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-  fir::runtime::genParityDescriptor(*firBuilder, loc, result, mask, dim);
-  checkCallOpFromResultBox(result, "_FortranAParityDim", 3);
-}
+// TEST_F(RuntimeCallTest, genParityDescriptorTest) {
+//   mlir::Location loc = firBuilder->getUnknownLoc();
+//   mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+//   mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+//   mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+//   fir::runtime::genParityDescriptor(*firBuilder, loc, result, mask, dim);
+//   checkCallOpFromResultBox(result, "_FortranAParityDim", 3);
+// }
 
 void testGenSum(
     fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
@@ -349,10 +349,10 @@ TEST_F(RuntimeCallTest, genMaxvalCharTest) {
       *firBuilder, fir::runtime::genMaxvalChar, "_FortranAMaxvalCharacter", 3);
 }
 
-TEST_F(RuntimeCallTest, genMinvalCharTest) {
-  checkGenMxxvalChar(
-      *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
-}
+// TEST_F(RuntimeCallTest, genMinvalCharTest) {
+//   checkGenMxxvalChar(
+//       *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
+// }
 
 void checkGen4argsDim(fir::FirOpBuilder &builder,
     void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
diff --git a/flang/unittests/Optimizer/FIRTypesTest.cpp b/flang/unittests/Optimizer/FIRTypesTest.cpp
index 238aa6939d5df..5ea621eebcdd4 100644
--- a/flang/unittests/Optimizer/FIRTypesTest.cpp
+++ b/flang/unittests/Optimizer/FIRTypesTest.cpp
@@ -125,33 +125,33 @@ TEST_F(FIRTypesTest, isUnlimitedPolymorphicTypeTest) {
 }
 
 // Test fir::isBoxedRecordType from flang/Optimizer/Dialect/FIRType.h.
-TEST_F(FIRTypesTest, isBoxedRecordType) {
-  mlir::Type recTy = fir::RecordType::get(&context, "dt");
-  mlir::Type seqRecTy =
-      fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, recTy);
-  mlir::Type ty = fir::BoxType::get(recTy);
-  EXPECT_TRUE(fir::isBoxedRecordType(ty));
-  EXPECT_TRUE(fir::isBoxedRecordType(fir::ReferenceType::get(ty)));
-
-  // TYPE(T), ALLOCATABLE
-  ty = fir::BoxType::get(fir::HeapType::get(recTy));
-  EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-  // TYPE(T), POINTER
-  ty = fir::BoxType::get(fir::PointerType::get(recTy));
-  EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-  // TYPE(T), DIMENSION(10)
-  ty = fir::BoxType::get(fir::SequenceType::get({10}, recTy));
-  EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-  // TYPE(T), DIMENSION(:)
-  ty = fir::BoxType::get(seqRecTy);
-  EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-  EXPECT_FALSE(fir::isBoxedRecordType(fir::BoxType::get(
-      fir::ReferenceType::get(mlir::IntegerType::get(&context, 32)))));
-}
+// TEST_F(FIRTypesTest, isBoxedRecordType) {
+//   mlir::Type recTy = fir::RecordType::get(&context, "dt");
+//   mlir::Type seqRecTy =
+//       fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, recTy);
+//   mlir::Type ty = fir::BoxType::get(recTy);
+//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
+//   EXPECT_TRUE(fir::isBoxedRecordType(fir::ReferenceType::get(ty)));
+
+//   // TYPE(T), ALLOCATABLE
+//   ty = fir::BoxType::get(fir::HeapType::get(recTy));
+//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+//   // TYPE(T), POINTER
+//   ty = fir::BoxType::get(fir::PointerType::get(recTy));
+//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+//   // TYPE(T), DIMENSION(10)
+//   ty = fir::BoxType::get(fir::SequenceType::get({10}, recTy));
+//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+//   // TYPE(T), DIMENSION(:)
+//   ty = fir::BoxType::get(seqRecTy);
+//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+//   EXPECT_FALSE(fir::isBoxedRecordType(fir::BoxType::get(
+//       fir::ReferenceType::get(mlir::IntegerType::get(&context, 32)))));
+// }
 
 // Test fir::isScalarBoxedRecordType from flang/Optimizer/Dialect/FIRType.h.
 TEST_F(FIRTypesTest, isScalarBoxedRecordType) {
diff --git a/flang/unittests/Optimizer/FortranVariableTest.cpp b/flang/unittests/Optimizer/FortranVariableTest.cpp
index 87efb624735cf..ae48cdb18533e 100644
--- a/flang/unittests/Optimizer/FortranVariableTest.cpp
+++ b/flang/unittests/Optimizer/FortranVariableTest.cpp
@@ -42,29 +42,29 @@ struct FortranVariableTest : public testing::Test {
   std::unique_ptr<mlir::OpBuilder> builder;
 };
 
-TEST_F(FortranVariableTest, SimpleScalar) {
-  mlir::Location loc = getLoc();
-  mlir::Type eleType = mlir::FloatType::getF32(&context);
-  mlir::Value addr = builder->create<fir::AllocaOp>(loc, eleType);
-  auto name = mlir::StringAttr::get(&context, "x");
-  auto declare = builder->create<fir::DeclareOp>(loc, addr.getType(), addr,
-      /*shape=*/mlir::Value{}, /*typeParams=*/std::nullopt,
-      /*dummy_scope=*/nullptr, name,
-      /*fortran_attrs=*/fir::FortranVariableFlagsAttr{},
-      /*data_attr=*/cuf::DataAttributeAttr{});
+// TEST_F(FortranVariableTest, SimpleScalar) {
+//   mlir::Location loc = getLoc();
+//   mlir::Type eleType = mlir::FloatType::getF32(&context);
+//   mlir::Value addr = builder->create<fir::AllocaOp>(loc, eleType);
+//   auto name = mlir::StringAttr::get(&context, "x");
+//   auto declare = builder->create<fir::DeclareOp>(loc, addr.getType(), addr,
+//       /*shape=*/mlir::Value{}, /*typeParams=*/std::nullopt,
+//       /*dummy_scope=*/nullptr, name,
+//       /*fortran_attrs=*/fir::FortranVariableFlagsAttr{},
+//       /*data_attr=*/cuf::DataAttributeAttr{});
 
-  fir::FortranVariableOpInterface fortranVariable = declare;
-  EXPECT_FALSE(fortranVariable.isArray());
-  EXPECT_FALSE(fortranVariable.isCharacter());
-  EXPECT_FALSE(fortranVariable.isPointer());
-  EXPECT_FALSE(fortranVariable.isAllocatable());
-  EXPECT_FALSE(fortranVariable.hasExplicitCharLen());
-  EXPECT_EQ(fortranVariable.getElementType(), eleType);
-  EXPECT_EQ(fortranVariable.getElementOrSequenceType(),
-      fortranVariable.getElementType());
-  EXPECT_NE(fortranVariable.getBase(), addr);
-  EXPECT_EQ(fortranVariable.getBase().getType(), addr.getType());
-}
+//   fir::FortranVariableOpInterface fortranVariable = declare;
+//   EXPECT_FALSE(fortranVariable.isArray());
+//   EXPECT_FALSE(fortranVariable.isCharacter());
+//   EXPECT_FALSE(fortranVariable.isPointer());
+//   EXPECT_FALSE(fortranVariable.isAllocatable());
+//   EXPECT_FALSE(fortranVariable.hasExplicitCharLen());
+//   EXPECT_EQ(fortranVariable.getElementType(), eleType);
+//   EXPECT_EQ(fortranVariable.getElementOrSequenceType(),
+//       fortranVariable.getElementType());
+//   EXPECT_NE(fortranVariable.getBase(), addr);
+//   EXPECT_EQ(fortranVariable.getBase().getType(), addr.getType());
+// }
 
 TEST_F(FortranVariableTest, CharacterScalar) {
   mlir::Location loc = getLoc();
diff --git a/flang/unittests/Optimizer/InternalNamesTest.cpp b/flang/unittests/Optimizer/InternalNamesTest.cpp
index 058bbeef9b007..470791d41541a 100644
--- a/flang/unittests/Optimizer/InternalNamesTest.cpp
+++ b/flang/unittests/Optimizer/InternalNamesTest.cpp
@@ -88,38 +88,38 @@ TEST(InternalNamesTest, doTypeTest) {
   ASSERT_EQ(actual, expectedMangledName);
 }
 
-TEST(InternalNamesTest, doIntrinsicTypeDescriptorTest) {
-  using IntrinsicType = fir::NameUniquer::IntrinsicType;
-  std::string actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::REAL, 42);
-  std::string expectedMangledName = "_QYIrealK42";
-  ASSERT_EQ(actual, expectedMangledName);
-
-  actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::REAL, {});
-  expectedMangledName = "_QYIrealK0";
-  ASSERT_EQ(actual, expectedMangledName);
-
-  actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::INTEGER, 3);
-  expectedMangledName = "_QYIintegerK3";
-  ASSERT_EQ(actual, expectedMangledName);
-
-  actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::LOGICAL, 2);
-  expectedMangledName = "_QYIlogicalK2";
-  ASSERT_EQ(actual, expectedMangledName);
-
-  actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::CHARACTER, 4);
-  expectedMangledName = "_QYIcharacterK4";
-  ASSERT_EQ(actual, expectedMangledName);
-
-  actual = NameUniquer::doIntrinsicTypeDescriptor(
-      {}, {}, 0, IntrinsicType::COMPLEX, 4);
-  expectedMangledName = "_QYIcomplexK4";
-  ASSERT_EQ(actual, expectedMangledName);
-}
+// TEST(InternalNamesTest, doIntrinsicTypeDescriptorTest) {
+//   using IntrinsicType = fir::NameUniquer::IntrinsicType;
+//   std::string actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::REAL, 42);
+//   std::string expectedMangledName = "_QYIrealK42";
+//   ASSERT_EQ(actual, expectedMangledName);
+
+//   actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::REAL, {});
+//   expectedMangledName = "_QYIrealK0";
+//   ASSERT_EQ(actual, expectedMangledName);
+
+//   actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::INTEGER, 3);
+//   expectedMangledName = "_QYIintegerK3";
+//   ASSERT_EQ(actual, expectedMangledName);
+
+//   actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::LOGICAL, 2);
+//   expectedMangledName = "_QYIlogicalK2";
+//   ASSERT_EQ(actual, expectedMangledName);
+
+//   actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::CHARACTER, 4);
+//   expectedMangledName = "_QYIcharacterK4";
+//   ASSERT_EQ(actual, expectedMangledName);
+
+//   actual = NameUniquer::doIntrinsicTypeDescriptor(
+//       {}, {}, 0, IntrinsicType::COMPLEX, 4);
+//   expectedMangledName = "_QYIcomplexK4";
+//   ASSERT_EQ(actual, expectedMangledName);
+// }
 
 TEST(InternalNamesTest, doDispatchTableTest) {
   std::string actual =
diff --git a/flang/unittests/Runtime/CharacterTest.cpp b/flang/unittests/Runtime/CharacterTest.cpp
index e54fd8a5075f6..e9522fae9a2c8 100644
--- a/flang/unittests/Runtime/CharacterTest.cpp
+++ b/flang/unittests/Runtime/CharacterTest.cpp
@@ -199,32 +199,32 @@ struct CharacterComparisonTests : public ::testing::Test {
 
 TYPED_TEST_SUITE(CharacterComparisonTests, CharacterTypes, );
 
-TYPED_TEST(CharacterComparisonTests, CompareCharacters) {
-  for (auto &[x, y, xBytes, yBytes, expect] : this->parameters) {
-    int cmp{this->characterComparisonFunc(x, y, xBytes, yBytes)};
-    TypeParam buf[2][8];
-    std::memset(buf, 0, sizeof buf);
-    std::memcpy(buf[0], x, xBytes);
-    std::memcpy(buf[1], y, yBytes);
-    ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
-                           << y << "'(" << yBytes << "), got " << cmp
-                           << ", should be " << expect << '\n';
-
-    // Perform the same test with the parameters reversed and the difference
-    // negated
-    std::swap(x, y);
-    std::swap(xBytes, yBytes);
-    expect = -expect;
-
-    cmp = this->characterComparisonFunc(x, y, xBytes, yBytes);
-    std::memset(buf, 0, sizeof buf);
-    std::memcpy(buf[0], x, xBytes);
-    std::memcpy(buf[1], y, yBytes);
-    ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
-                           << y << "'(" << yBytes << "'), got " << cmp
-                           << ", should be " << expect << '\n';
-  }
-}
+// TYPED_TEST(CharacterComparisonTests, CompareCharacters) {
+//   for (auto &[x, y, xBytes, yBytes, expect] : this->parameters) {
+//     int cmp{this->characterComparisonFunc(x, y, xBytes, yBytes)};
+//     TypeParam buf[2][8];
+//     std::memset(buf, 0, sizeof buf);
+//     std::memcpy(buf[0], x, xBytes);
+//     std::memcpy(buf[1], y, yBytes);
+//     ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
+//                            << y << "'(" << yBytes << "), got " << cmp
+//                            << ", should be " << expect << '\n';
+
+//     // Perform the same test with the parameters reversed and the difference
+//     // negated
+//     std::swap(x, y);
+//     std::swap(xBytes, yBytes);
+//     expect = -expect;
+
+//     cmp = this->characterComparisonFunc(x, y, xBytes, yBytes);
+//     std::memset(buf, 0, sizeof buf);
+//     std::memcpy(buf[0], x, xBytes);
+//     std::memcpy(buf[1], y, yBytes);
+//     ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
+//                            << y << "'(" << yBytes << "'), got " << cmp
+//                            << ", should be " << expect << '\n';
+//   }
+// }
 
 // Test MIN() and MAX()
 struct ExtremumTestCase {
@@ -275,14 +275,14 @@ TYPED_TEST(ExtremumTests, MinTests) {
   RunExtremumTests<TypeParam>("MIN", RTNAME(CharacterMin), tests);
 }
 
-TYPED_TEST(ExtremumTests, MaxTests) {
-  static std::vector<ExtremumTestCase> tests{
-      {{}, {"a"}, {"z"}, {"z"}},
-      {{1}, {"zaa"}, {"aaaaa"}, {"zaa  "}},
-      {{1, 1, 1}, {"aaaaa"}, {"aazaa"}, {"aazaa"}},
-  };
-  RunExtremumTests<TypeParam>("MAX", RTNAME(CharacterMax), tests);
-}
+// TYPED_TEST(ExtremumTests, MaxTests) {
+//   static std::vector<ExtremumTestCase> tests{
+//       {{}, {"a"}, {"z"}, {"z"}},
+//       {{1}, {"zaa"}, {"aaaaa"}, {"zaa  "}},
+//       {{1, 1, 1}, {"aaaaa"}, {"aazaa"}, {"aazaa"}},
+//   };
+//   RunExtremumTests<TypeParam>("MAX", RTNAME(CharacterMax), tests);
+// }
 
 template <typename CHAR>
 void RunAllocationTest(const char *xRaw, const char *yRaw) {
@@ -373,20 +373,20 @@ TYPED_TEST(SearchTests, ScanTests) {
   RunSearchTests("SCAN", tests, std::get<SearchFunction<TypeParam>>(functions));
 }
 
-TYPED_TEST(SearchTests, VerifyTests) {
-  static SearchFunctions functions{
-      RTNAME(Verify1), RTNAME(Verify2), RTNAME(Verify4)};
-  static std::vector<SearchTestCase> tests{
-      {"abc", "abc", false, 0},
-      {"abc", "abc", true, 0},
-      {"abc", "cde", false, 1},
-      {"abc", "cde", true, 2},
-      {"abc", "x", false, 1},
-      {"", "x", false, 0},
-  };
-  RunSearchTests(
-      "VERIFY", tests, std::get<SearchFunction<TypeParam>>(functions));
-}
+// TYPED_TEST(SearchTests, VerifyTests) {
+//   static SearchFunctions functions{
+//       RTNAME(Verify1), RTNAME(Verify2), RTNAME(Verify4)};
+//   static std::vector<SearchTestCase> tests{
+//       {"abc", "abc", false, 0},
+//       {"abc", "abc", true, 0},
+//       {"abc", "cde", false, 1},
+//       {"abc", "cde", true, 2},
+//       {"abc", "x", false, 1},
+//       {"", "x", false, 0},
+//   };
+//   RunSearchTests(
+//       "VERIFY", tests, std::get<SearchFunction<TypeParam>>(functions));
+// }
 
 // Test REPEAT()
 template <typename CHAR> struct RepeatTests : public ::testing::Test {};
diff --git a/flang/unittests/Runtime/CommandTest.cpp b/flang/unittests/Runtime/CommandTest.cpp
index 08daa4ba37f26..c67eb091d0b11 100644
--- a/flang/unittests/Runtime/CommandTest.cpp
+++ b/flang/unittests/Runtime/CommandTest.cpp
@@ -308,21 +308,21 @@ TEST_F(ZeroArguments, GetCommandArgument) {
 
 TEST_F(ZeroArguments, GetCommand) { CheckCommandValue(commandOnlyArgv, 1); }
 
-TEST_F(ZeroArguments, ECLValidCommandAndPadSync) {
-  OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
-  bool wait{true};
-  OwningPtr<Descriptor> exitStat{EmptyIntDescriptor()};
-  OwningPtr<Descriptor> cmdStat{EmptyIntDescriptor()};
-  OwningPtr<Descriptor> cmdMsg{CharDescriptor("No change")};
-
-  RTNAME(ExecuteCommandLine)
-  (*command.get(), wait, exitStat.get(), cmdStat.get(), cmdMsg.get());
-
-  std::string spaces(cmdMsg->ElementBytes(), ' ');
-  CheckDescriptorEqInt<std::int64_t>(exitStat.get(), 0);
-  CheckDescriptorEqInt<std::int64_t>(cmdStat.get(), 0);
-  CheckDescriptorEqStr(cmdMsg.get(), "No change");
-}
+// TEST_F(ZeroArguments, ECLValidCommandAndPadSync) {
+//   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
+//   bool wait{true};
+//   OwningPtr<Descriptor> exitStat{EmptyIntDescriptor()};
+//   OwningPtr<Descriptor> cmdStat{EmptyIntDescriptor()};
+//   OwningPtr<Descriptor> cmdMsg{CharDescriptor("No change")};
+
+//   RTNAME(ExecuteCommandLine)
+//   (*command.get(), wait, exitStat.get(), cmdStat.get(), cmdMsg.get());
+
+//   std::string spaces(cmdMsg->ElementBytes(), ' ');
+//   CheckDescriptorEqInt<std::int64_t>(exitStat.get(), 0);
+//   CheckDescriptorEqInt<std::int64_t>(cmdStat.get(), 0);
+//   CheckDescriptorEqStr(cmdMsg.get(), "No change");
+// }
 
 TEST_F(ZeroArguments, ECLValidCommandStatusSetSync) {
   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
@@ -404,14 +404,14 @@ TEST_F(ZeroArguments, ECLInvalidCommandParentNotTerminatedAsync) {
   CheckDescriptorEqStr(cmdMsg.get(), "No change");
 }
 
-TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectSync) {
-  OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
+// TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectSync) {
+//   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
 
-  EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
-      *command.get(), false, nullptr, nullptr, nullptr));
-  EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
-      *command.get(), true, nullptr, nullptr, nullptr));
-}
+//   EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
+//       *command.get(), false, nullptr, nullptr, nullptr));
+//   EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
+//       *command.get(), true, nullptr, nullptr, nullptr));
+// }
 
 TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectAsync) {
   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
@@ -560,18 +560,18 @@ TEST_F(SeveralArguments, GetCommand) {
   CheckMissingCommandValue("Missing argument");
 }
 
-TEST_F(SeveralArguments, CommandErrMsgTooShort) {
-  OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
-  OwningPtr<Descriptor> length{EmptyIntDescriptor()};
-  OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
+// TEST_F(SeveralArguments, CommandErrMsgTooShort) {
+//   OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
+//   OwningPtr<Descriptor> length{EmptyIntDescriptor()};
+//   OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
 
-  EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), errMsg.get()), 0);
+//   EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), errMsg.get()), 0);
 
-  std::string spaces(value->ElementBytes(), ' ');
-  CheckDescriptorEqStr(value.get(), spaces);
-  CheckDescriptorEqInt<std::int64_t>(length.get(), 0);
-  CheckDescriptorEqStr(errMsg.get(), "Mis");
-}
+//   std::string spaces(value->ElementBytes(), ' ');
+//   CheckDescriptorEqStr(value.get(), spaces);
+//   CheckDescriptorEqInt<std::int64_t>(length.get(), 0);
+//   CheckDescriptorEqStr(errMsg.get(), "Mis");
+// }
 
 TEST_F(SeveralArguments, GetCommandCanTakeNull) {
   EXPECT_GT(RTNAME(GetCommand)(nullptr, nullptr, nullptr), 0);
@@ -700,11 +700,11 @@ TEST_F(EnvironmentVariables, NoTrim) {
   }
 }
 
-TEST_F(EnvironmentVariables, Empty) {
-  if (EnableFineGrainedTests()) {
-    CheckEnvVarValue("", "EMPTY");
-  }
-}
+// TEST_F(EnvironmentVariables, Empty) {
+//   if (EnableFineGrainedTests()) {
+//     CheckEnvVarValue("", "EMPTY");
+//   }
+// }
 
 TEST_F(EnvironmentVariables, NoValueOrErrmsg) {
   ASSERT_EQ(std::getenv("DOESNT_EXIST"), nullptr)
diff --git a/flang/unittests/Runtime/Complex.cpp b/flang/unittests/Runtime/Complex.cpp
index 46f3ad2f2712b..f87b890c825d3 100644
--- a/flang/unittests/Runtime/Complex.cpp
+++ b/flang/unittests/Runtime/Complex.cpp
@@ -133,23 +133,23 @@ TEST(Complex, cpowk) {
       cpowk(0.f + 1if, std::numeric_limits<std::int64_t>::min()), 1.f + 0if);
 }
 
-TEST(Complex, zpowi) {
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 0), 1. + 0i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 1), 3. + 4i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 2), -7. + 24i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 3), -117. + 44i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 4), -527. - 336i);
-
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, -2), -0.0112 - 0.0384i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 10), -237. - 3116i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -10), -9.32293628 - 7.29848564i);
-
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 5), -38. + 41i);
-  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -5), -1.12183773 + 3.25291503i);
-
-  EXPECT_COMPLEX_DOUBLE_EQ(
-      zpowi(0. + 1i, std::numeric_limits<std::int32_t>::min()), 1. + 0i);
-}
+// TEST(Complex, zpowi) {
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 0), 1. + 0i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 1), 3. + 4i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 2), -7. + 24i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 3), -117. + 44i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 4), -527. - 336i);
+
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, -2), -0.0112 - 0.0384i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 10), -237. - 3116i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -10), -9.32293628 - 7.29848564i);
+
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 5), -38. + 41i);
+//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -5), -1.12183773 + 3.25291503i);
+
+//   EXPECT_COMPLEX_DOUBLE_EQ(
+//       zpowi(0. + 1i, std::numeric_limits<std::int32_t>::min()), 1. + 0i);
+// }
 
 TEST(Complex, zpowk) {
   EXPECT_COMPLEX_DOUBLE_EQ(zpowk(3. + 4i, 0), 1. + 0i);
diff --git a/flang/unittests/Runtime/ExternalIOTest.cpp b/flang/unittests/Runtime/ExternalIOTest.cpp
index 13327964e12a4..0f3da0784f9d4 100644
--- a/flang/unittests/Runtime/ExternalIOTest.cpp
+++ b/flang/unittests/Runtime/ExternalIOTest.cpp
@@ -585,103 +585,103 @@ TEST(ExternalIOTests, TestNonAvancingInput) {
       << "EndIoStatement() for Close";
 }
 
-TEST(ExternalIOTests, TestWriteAfterNonAvancingInput) {
-  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
-  //   FORM='FORMATTED',STATUS='SCRATCH')
-  auto *io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
-  ASSERT_TRUE(IONAME(SetAccess)(io, "SEQUENTIAL", 10))
-      << "SetAccess(SEQUENTIAL)";
-  ASSERT_TRUE(IONAME(SetAction)(io, "READWRITE", 9)) << "SetAction(READWRITE)";
-  ASSERT_TRUE(IONAME(SetForm)(io, "FORMATTED", 9)) << "SetForm(FORMATTED)";
-  ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
-
-  int unit{-1};
-  ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for OpenNewUnit";
-
-  // Write the file to be used for the input test.
-  static constexpr std::string_view records[] = {"ABCDEFGHIJKLMNOPQRST"};
-  static constexpr std::string_view fmt{"(A)"};
-  for (const auto &record : records) {
-    // WRITE(UNIT=unit,FMT=fmt) record
-    io = IONAME(BeginExternalFormattedOutput)(
-        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-    ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
-        << "OutputAscii()";
-    ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-        << "EndIoStatement() for OutputAscii";
-  }
-
-  // REWIND(UNIT=unit)
-  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for Rewind";
-
-  struct TestItems {
-    std::string item;
-    int expectedIoStat;
-    std::string expectedItemValue;
-  };
-  // Actual non advancing input IO test
-  TestItems inputItems[]{
-      {std::string(4, '+'), IostatOk, "ABCD"},
-      {std::string(4, '+'), IostatOk, "EFGH"},
-  };
-
-  int j{0};
-  for (auto &inputItem : inputItems) {
-    // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
-    io = IONAME(BeginExternalFormattedInput)(
-        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-    IONAME(EnableHandlers)(io, true, false, false, false, false);
-    ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
-    ASSERT_TRUE(
-        IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length()))
-        << "InputAscii() " << j;
-    ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
-        << "EndIoStatement() for Read " << j;
-    ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
-        << "Input-item value after non advancing read " << j;
-    j++;
-  }
-
-  // WRITE(UNIT=unit, FMT=fmt, IOSTAT=iostat) outputItem.
-  static constexpr std::string_view outputItem{"XYZ"};
-  // WRITE(UNIT=unit,FMT=fmt) record
-  io = IONAME(BeginExternalFormattedOutput)(
-      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-  ASSERT_TRUE(IONAME(OutputAscii)(io, outputItem.data(), outputItem.length()))
-      << "OutputAscii()";
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for OutputAscii";
-
-  // Verify that the output was written in the record read in non advancing
-  // mode, after the read part, and that the end was truncated.
-
-  // REWIND(UNIT=unit)
-  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for Rewind";
-
-  std::string resultRecord(20, '+');
-  std::string expectedRecord{"ABCDEFGHXYZ         "};
-  // READ(UNIT=unit, FMT=fmt, IOSTAT=iostat) result
-  io = IONAME(BeginExternalFormattedInput)(
-      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-  IONAME(EnableHandlers)(io, true, false, false, false, false);
-  ASSERT_TRUE(
-      IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
-      << "InputAscii() ";
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for Read ";
-  ASSERT_EQ(resultRecord, expectedRecord)
-      << "Record after non advancing read followed by write";
-  // CLOSE(UNIT=unit)
-  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
-  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-      << "EndIoStatement() for Close";
-}
+// TEST(ExternalIOTests, TestWriteAfterNonAvancingInput) {
+//   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+//   //   FORM='FORMATTED',STATUS='SCRATCH')
+//   auto *io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+//   ASSERT_TRUE(IONAME(SetAccess)(io, "SEQUENTIAL", 10))
+//       << "SetAccess(SEQUENTIAL)";
+//   ASSERT_TRUE(IONAME(SetAction)(io, "READWRITE", 9)) << "SetAction(READWRITE)";
+//   ASSERT_TRUE(IONAME(SetForm)(io, "FORMATTED", 9)) << "SetForm(FORMATTED)";
+//   ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
+
+//   int unit{-1};
+//   ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for OpenNewUnit";
+
+//   // Write the file to be used for the input test.
+//   static constexpr std::string_view records[] = {"ABCDEFGHIJKLMNOPQRST"};
+//   static constexpr std::string_view fmt{"(A)"};
+//   for (const auto &record : records) {
+//     // WRITE(UNIT=unit,FMT=fmt) record
+//     io = IONAME(BeginExternalFormattedOutput)(
+//         fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+//     ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
+//         << "OutputAscii()";
+//     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//         << "EndIoStatement() for OutputAscii";
+//   }
+
+//   // REWIND(UNIT=unit)
+//   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for Rewind";
+
+//   struct TestItems {
+//     std::string item;
+//     int expectedIoStat;
+//     std::string expectedItemValue;
+//   };
+//   // Actual non advancing input IO test
+//   TestItems inputItems[]{
+//       {std::string(4, '+'), IostatOk, "ABCD"},
+//       {std::string(4, '+'), IostatOk, "EFGH"},
+//   };
+
+//   int j{0};
+//   for (auto &inputItem : inputItems) {
+//     // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
+//     io = IONAME(BeginExternalFormattedInput)(
+//         fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+//     IONAME(EnableHandlers)(io, true, false, false, false, false);
+//     ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
+//     ASSERT_TRUE(
+//         IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length()))
+//         << "InputAscii() " << j;
+//     ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
+//         << "EndIoStatement() for Read " << j;
+//     ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
+//         << "Input-item value after non advancing read " << j;
+//     j++;
+//   }
+
+//   // WRITE(UNIT=unit, FMT=fmt, IOSTAT=iostat) outputItem.
+//   static constexpr std::string_view outputItem{"XYZ"};
+//   // WRITE(UNIT=unit,FMT=fmt) record
+//   io = IONAME(BeginExternalFormattedOutput)(
+//       fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+//   ASSERT_TRUE(IONAME(OutputAscii)(io, outputItem.data(), outputItem.length()))
+//       << "OutputAscii()";
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for OutputAscii";
+
+//   // Verify that the output was written in the record read in non advancing
+//   // mode, after the read part, and that the end was truncated.
+
+//   // REWIND(UNIT=unit)
+//   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for Rewind";
+
+//   std::string resultRecord(20, '+');
+//   std::string expectedRecord{"ABCDEFGHXYZ         "};
+//   // READ(UNIT=unit, FMT=fmt, IOSTAT=iostat) result
+//   io = IONAME(BeginExternalFormattedInput)(
+//       fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+//   IONAME(EnableHandlers)(io, true, false, false, false, false);
+//   ASSERT_TRUE(
+//       IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
+//       << "InputAscii() ";
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for Read ";
+//   ASSERT_EQ(resultRecord, expectedRecord)
+//       << "Record after non advancing read followed by write";
+//   // CLOSE(UNIT=unit)
+//   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+//       << "EndIoStatement() for Close";
+// }
 
 TEST(ExternalIOTests, TestWriteAfterEndfile) {
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
diff --git a/flang/unittests/Runtime/Format.cpp b/flang/unittests/Runtime/Format.cpp
index 01803c628de26..cdcdc19aff54a 100644
--- a/flang/unittests/Runtime/Format.cpp
+++ b/flang/unittests/Runtime/Format.cpp
@@ -145,18 +145,18 @@ TEST(FormatTests, FormatStringTraversal) {
 
 struct InvalidFormatFailure : CrashHandlerFixture {};
 
-TEST(InvalidFormatFailure, ParenMismatch) {
-  static constexpr const char *format{"("};
-  static constexpr int repeat{1};
-
-  TestFormatContext context;
-  FormatControl<decltype(context)> control{
-      context, format, std::strlen(format)};
-
-  ASSERT_DEATH(
-      context.Report(/*edit=*/control.GetNextDataEdit(context, repeat)),
-      R"(FORMAT missing at least one '\)')");
-}
+// TEST(InvalidFormatFailure, ParenMismatch) {
+//   static constexpr const char *format{"("};
+//   static constexpr int repeat{1};
+
+//   TestFormatContext context;
+//   FormatControl<decltype(context)> control{
+//       context, format, std::strlen(format)};
+
+//   ASSERT_DEATH(
+//       context.Report(/*edit=*/control.GetNextDataEdit(context, repeat)),
+//       R"(FORMAT missing at least one '\)')");
+// }
 
 TEST(InvalidFormatFailure, MissingPrecision) {
   static constexpr const char *format{"(F9.)"};
diff --git a/flang/unittests/Runtime/ListInputTest.cpp b/flang/unittests/Runtime/ListInputTest.cpp
index a4eba5283add6..c53a10a0af640 100644
--- a/flang/unittests/Runtime/ListInputTest.cpp
+++ b/flang/unittests/Runtime/ListInputTest.cpp
@@ -155,35 +155,35 @@ using ParamTy = std::tuple<std::string, std::vector<int>>;
 
 struct SimpleListInputTest : testing::TestWithParam<ParamTy> {};
 
-TEST_P(SimpleListInputTest, TestListInput) {
-  auto [formatBuffer, expectedOutput] = GetParam();
-  constexpr int numBuffers{1};
-
-  StaticDescriptor<1> staticDescriptor;
-  Descriptor &whole{staticDescriptor.descriptor()};
-  SubscriptValue extent[]{numBuffers};
-  whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
-      formatBuffer.data(), 1, extent, CFI_attribute_pointer);
-  whole.Check();
-  auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
-
-  const auto listInputLength{expectedOutput.size()};
-  std::vector<std::int64_t> actualOutput(listInputLength);
-  for (std::size_t j = 0; j < listInputLength; ++j) {
-    IONAME(InputInteger)(cookie, actualOutput[j]);
-  }
-
-  const auto status{IONAME(EndIoStatement)(cookie)};
-  ASSERT_EQ(status, 0) << "list-directed input failed, status "
-                       << static_cast<int>(status) << '\n';
-
-  // Verify the calls to _InputInteger_ resulted in _expectedOutput_
-  for (std::size_t j = 0; j < listInputLength; ++j) {
-    ASSERT_EQ(actualOutput[j], expectedOutput[j])
-        << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
-        << actualOutput[j] << '\n';
-  }
-}
+// TEST_P(SimpleListInputTest, TestListInput) {
+//   auto [formatBuffer, expectedOutput] = GetParam();
+//   constexpr int numBuffers{1};
+
+//   StaticDescriptor<1> staticDescriptor;
+//   Descriptor &whole{staticDescriptor.descriptor()};
+//   SubscriptValue extent[]{numBuffers};
+//   whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
+//       formatBuffer.data(), 1, extent, CFI_attribute_pointer);
+//   whole.Check();
+//   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
+
+//   const auto listInputLength{expectedOutput.size()};
+//   std::vector<std::int64_t> actualOutput(listInputLength);
+//   for (std::size_t j = 0; j < listInputLength; ++j) {
+//     IONAME(InputInteger)(cookie, actualOutput[j]);
+//   }
+
+//   const auto status{IONAME(EndIoStatement)(cookie)};
+//   ASSERT_EQ(status, 0) << "list-directed input failed, status "
+//                        << static_cast<int>(status) << '\n';
+
+//   // Verify the calls to _InputInteger_ resulted in _expectedOutput_
+//   for (std::size_t j = 0; j < listInputLength; ++j) {
+//     ASSERT_EQ(actualOutput[j], expectedOutput[j])
+//         << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
+//         << actualOutput[j] << '\n';
+//   }
+// }
 
 INSTANTIATE_TEST_SUITE_P(SimpleListInputTestInstantiation, SimpleListInputTest,
     testing::Values(std::make_tuple("", std::vector<int>{}),
diff --git a/flang/unittests/Runtime/MiscIntrinsic.cpp b/flang/unittests/Runtime/MiscIntrinsic.cpp
index 7e19ed250bdc0..6dff30a5c1efc 100644
--- a/flang/unittests/Runtime/MiscIntrinsic.cpp
+++ b/flang/unittests/Runtime/MiscIntrinsic.cpp
@@ -68,21 +68,21 @@ TEST(MiscIntrinsic, TransferSize) {
   EXPECT_EQ(result.OffsetElement<float>()[1], 2.2F);
   result.Destroy();
 }
-TEST(MiscIntrinsic, TransferSizeScalarMold) {
-  StaticDescriptor<2, true, 2> staticDesc[2];
-  auto &result{staticDesc[0].descriptor()};
-  std::complex<float> sourecStorage{1.1F, -2.2F};
-  auto source{Descriptor::Create(TypeCategory::Complex, 4,
-      reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
-      CFI_attribute_pointer)};
-  auto &mold{staticDesc[1].descriptor()};
-  mold.Establish(TypeCategory::Real, 4, nullptr, 0, nullptr);
-  RTNAME(TransferSize)(result, *source, mold, __FILE__, __LINE__, 2);
-  EXPECT_EQ(result.rank(), 1);
-  EXPECT_EQ(result.GetDimension(0).LowerBound(), 1);
-  EXPECT_EQ(result.GetDimension(0).Extent(), 2);
-  EXPECT_EQ(result.type().raw(), (TypeCode{TypeCategory::Real, 4}.raw()));
-  EXPECT_EQ(result.OffsetElement<float>()[0], 1.1F);
-  EXPECT_EQ(result.OffsetElement<float>()[1], -2.2F);
-  result.Destroy();
-}
+// TEST(MiscIntrinsic, TransferSizeScalarMold) {
+//   StaticDescriptor<2, true, 2> staticDesc[2];
+//   auto &result{staticDesc[0].descriptor()};
+//   std::complex<float> sourecStorage{1.1F, -2.2F};
+//   auto source{Descriptor::Create(TypeCategory::Complex, 4,
+//       reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
+//       CFI_attribute_pointer)};
+//   auto &mold{staticDesc[1].descriptor()};
+//   mold.Establish(TypeCategory::Real, 4, nullptr, 0, nullptr);
+//   RTNAME(TransferSize)(result, *source, mold, __FILE__, __LINE__, 2);
+//   EXPECT_EQ(result.rank(), 1);
+//   EXPECT_EQ(result.GetDimension(0).LowerBound(), 1);
+//   EXPECT_EQ(result.GetDimension(0).Extent(), 2);
+//   EXPECT_EQ(result.type().raw(), (TypeCode{TypeCategory::Real, 4}.raw()));
+//   EXPECT_EQ(result.OffsetElement<float>()[0], 1.1F);
+//   EXPECT_EQ(result.OffsetElement<float>()[1], -2.2F);
+//   result.Destroy();
+// }
diff --git a/flang/unittests/Runtime/Numeric.cpp b/flang/unittests/Runtime/Numeric.cpp
index b69ff21ea79fb..98ec88abf9a93 100644
--- a/flang/unittests/Runtime/Numeric.cpp
+++ b/flang/unittests/Runtime/Numeric.cpp
@@ -31,15 +31,15 @@ TEST(Numeric, Floor) {
   EXPECT_EQ(RTNAME(Floor4_1)(Real<4>{0}), 0);
 }
 
-TEST(Numeric, Exponent) {
-  EXPECT_EQ(RTNAME(Exponent4_4)(Real<4>{0}), 0);
-  EXPECT_EQ(RTNAME(Exponent4_8)(Real<4>{1.0}), 1);
-  EXPECT_EQ(RTNAME(Exponent8_4)(Real<8>{4.1}), 3);
-  EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::infinity()),
-      std::numeric_limits<Int<8>>::max());
-  EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::quiet_NaN()),
-      std::numeric_limits<Int<8>>::max());
-}
+// TEST(Numeric, Exponent) {
+//   EXPECT_EQ(RTNAME(Exponent4_4)(Real<4>{0}), 0);
+//   EXPECT_EQ(RTNAME(Exponent4_8)(Real<4>{1.0}), 1);
+//   EXPECT_EQ(RTNAME(Exponent8_4)(Real<8>{4.1}), 3);
+//   EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::infinity()),
+//       std::numeric_limits<Int<8>>::max());
+//   EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::quiet_NaN()),
+//       std::numeric_limits<Int<8>>::max());
+// }
 
 TEST(Numeric, Fraction) {
   EXPECT_EQ(RTNAME(Fraction4)(Real<4>{0}), 0);
@@ -192,57 +192,57 @@ TEST(Numeric, SelectedIntKind) {
   EXPECT_EQ(RTNAME(SelectedIntKind)(__FILE__, __LINE__, &r5, 4), -1);
 }
 
-TEST(Numeric, SelectedRealKind) {
-  std::int8_t p_s = 1;
-  std::int16_t p[11] = {-10, 1, 1, 4, 50, 1, 1, 4, 1, 1, 50};
-  std::int32_t r[11] = {-1, 1, 1, 1, 2, 1, 20, 20, 100, 5000, 5000};
-  std::int64_t d[11] = {2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2};
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[0], 2, &r[0], 4, &d[0], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[1], 2, &r[1], 4, &d[1], 8),
-      -5);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[2], 2, &r[2], 4, &d[2], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[3], 2, &r[3], 4, &d[3], 8),
-      4);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[4], 2, &r[4], 4, &d[4], 8),
-      -1);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[5], 2, &r[5], 4, &d[5], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[6], 2, &r[6], 4, &d[6], 8),
-      3);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[7], 2, &r[7], 4, &d[7], 8),
-      4);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[8], 2, &r[8], 4, &d[8], 8),
-      8);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[9], 2, &r[9], 4, &d[9], 8),
-      -2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[10], 2, &r[10], 4, &d[10], 8),
-      -3);
-  EXPECT_EQ(
-      RTNAME(SelectedRealKind)(__FILE__, __LINE__, &p_s, 1, &r[0], 4, &d[0], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, nullptr, 0, &r[0], 4, &d[0], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[0], 2, nullptr, 0, &d[0], 8),
-      2);
-  EXPECT_EQ(RTNAME(SelectedRealKind)(
-                __FILE__, __LINE__, &p[0], 2, &r[0], 4, nullptr, 0),
-      2);
-}
+// TEST(Numeric, SelectedRealKind) {
+//   std::int8_t p_s = 1;
+//   std::int16_t p[11] = {-10, 1, 1, 4, 50, 1, 1, 4, 1, 1, 50};
+//   std::int32_t r[11] = {-1, 1, 1, 1, 2, 1, 20, 20, 100, 5000, 5000};
+//   std::int64_t d[11] = {2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[0], 2, &r[0], 4, &d[0], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[1], 2, &r[1], 4, &d[1], 8),
+//       -5);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[2], 2, &r[2], 4, &d[2], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[3], 2, &r[3], 4, &d[3], 8),
+//       4);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[4], 2, &r[4], 4, &d[4], 8),
+//       -1);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[5], 2, &r[5], 4, &d[5], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[6], 2, &r[6], 4, &d[6], 8),
+//       3);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[7], 2, &r[7], 4, &d[7], 8),
+//       4);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[8], 2, &r[8], 4, &d[8], 8),
+//       8);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[9], 2, &r[9], 4, &d[9], 8),
+//       -2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[10], 2, &r[10], 4, &d[10], 8),
+//       -3);
+//   EXPECT_EQ(
+//       RTNAME(SelectedRealKind)(__FILE__, __LINE__, &p_s, 1, &r[0], 4, &d[0], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, nullptr, 0, &r[0], 4, &d[0], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[0], 2, nullptr, 0, &d[0], 8),
+//       2);
+//   EXPECT_EQ(RTNAME(SelectedRealKind)(
+//                 __FILE__, __LINE__, &p[0], 2, &r[0], 4, nullptr, 0),
+//       2);
+// }
 
 TEST(Numeric, Spacing) {
   EXPECT_EQ(RTNAME(Spacing8)(Real<8>{0}), std::numeric_limits<Real<8>>::min());
diff --git a/flang/unittests/Runtime/NumericalFormatTest.cpp b/flang/unittests/Runtime/NumericalFormatTest.cpp
index 2a9f8f8d1dc4f..d480e41268b6b 100644
--- a/flang/unittests/Runtime/NumericalFormatTest.cpp
+++ b/flang/unittests/Runtime/NumericalFormatTest.cpp
@@ -336,21 +336,21 @@ TEST(IOApiTests, FormatOnes) {
   }
 }
 
-TEST(IOApiTests, FormatNegativeOnes) {
-  static constexpr std::tuple<const char *, const char *> negOnes[]{
-      {"(E32.17,';')", "        -0.10000000000000000E+01;"},
-      {"(F32.17,';')", "            -1.00000000000000000;"},
-      {"(G32.17,';')", "         -1.0000000000000000    ;"},
-      {"(EX32.17,';')", "       -0X8.00000000000000000P-3;"},
-      {"(G0,';')", "-1.;"},
-  };
-  for (auto const &[format, expect] : negOnes) {
-    std::string got;
-    ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
-        << "Failed to format " << format << ", expected '" << expect
-        << "', got '" << got << "'";
-  }
-}
+// TEST(IOApiTests, FormatNegativeOnes) {
+//   static constexpr std::tuple<const char *, const char *> negOnes[]{
+//       {"(E32.17,';')", "        -0.10000000000000000E+01;"},
+//       {"(F32.17,';')", "            -1.00000000000000000;"},
+//       {"(G32.17,';')", "         -1.0000000000000000    ;"},
+//       {"(EX32.17,';')", "       -0X8.00000000000000000P-3;"},
+//       {"(G0,';')", "-1.;"},
+//   };
+//   for (auto const &[format, expect] : negOnes) {
+//     std::string got;
+//     ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
+//         << "Failed to format " << format << ", expected '" << expect
+//         << "', got '" << got << "'";
+//   }
+// }
 
 // Each test case contains a raw uint64, a format string for a real value, and
 // the expected resulting string from formatting the raw uint64. The double
diff --git a/flang/unittests/Runtime/Pointer.cpp b/flang/unittests/Runtime/Pointer.cpp
index 4ce13ebc50a56..30edf82fbcf13 100644
--- a/flang/unittests/Runtime/Pointer.cpp
+++ b/flang/unittests/Runtime/Pointer.cpp
@@ -64,25 +64,25 @@ TEST(Pointer, DeallocatePolymorphic) {
   (*p, nullptr, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
 }
 
-TEST(Pointer, AllocateFromScalarSource) {
-  // REAL(4), POINTER :: p(:)
-  auto p{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, 4,
-      nullptr, 1, nullptr, CFI_attribute_pointer)};
-  // ALLOCATE(p(2:11), SOURCE=3.4)
-  float sourecStorage{3.4F};
-  auto s{Descriptor::Create(Fortran::common::TypeCategory::Real, 4,
-      reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
-      CFI_attribute_pointer)};
-  RTNAME(PointerSetBounds)(*p, 0, 2, 11);
-  RTNAME(PointerAllocateSource)
-  (*p, *s, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
-  EXPECT_TRUE(RTNAME(PointerIsAssociated)(*p));
-  EXPECT_EQ(p->Elements(), 10u);
-  EXPECT_EQ(p->GetDimension(0).LowerBound(), 2);
-  EXPECT_EQ(p->GetDimension(0).UpperBound(), 11);
-  EXPECT_EQ(*p->OffsetElement<float>(), 3.4F);
-  p->Destroy();
-}
+// TEST(Pointer, AllocateFromScalarSource) {
+//   // REAL(4), POINTER :: p(:)
+//   auto p{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, 4,
+//       nullptr, 1, nullptr, CFI_attribute_pointer)};
+//   // ALLOCATE(p(2:11), SOURCE=3.4)
+//   float sourecStorage{3.4F};
+//   auto s{Descriptor::Create(Fortran::common::TypeCategory::Real, 4,
+//       reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
+//       CFI_attribute_pointer)};
+//   RTNAME(PointerSetBounds)(*p, 0, 2, 11);
+//   RTNAME(PointerAllocateSource)
+//   (*p, *s, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
+//   EXPECT_TRUE(RTNAME(PointerIsAssociated)(*p));
+//   EXPECT_EQ(p->Elements(), 10u);
+//   EXPECT_EQ(p->GetDimension(0).LowerBound(), 2);
+//   EXPECT_EQ(p->GetDimension(0).UpperBound(), 11);
+//   EXPECT_EQ(*p->OffsetElement<float>(), 3.4F);
+//   p->Destroy();
+// }
 
 TEST(Pointer, AllocateSourceZeroSize) {
   using Fortran::common::TypeCategory;
diff --git a/flang/unittests/Runtime/RuntimeCrashTest.cpp b/flang/unittests/Runtime/RuntimeCrashTest.cpp
index a649051fdca0c..0753f76f23cc3 100644
--- a/flang/unittests/Runtime/RuntimeCrashTest.cpp
+++ b/flang/unittests/Runtime/RuntimeCrashTest.cpp
@@ -53,15 +53,15 @@ TEST(TestTerminator, CheckFailedTest) {
 //------------------------------------------------------------------------------
 struct TestIOCrash : CrashHandlerFixture {};
 
-TEST(TestIOCrash, InvalidFormatCharacterTest) {
-  static constexpr int bufferSize{1};
-  static char buffer[bufferSize];
-  static const char *format{"(C1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
-  ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xfeedface),
-      "Unknown 'C' edit descriptor in FORMAT");
-}
+// TEST(TestIOCrash, InvalidFormatCharacterTest) {
+//   static constexpr int bufferSize{1};
+//   static char buffer[bufferSize];
+//   static const char *format{"(C1)"};
+//   auto *cookie{IONAME(BeginInternalFormattedOutput)(
+//       buffer, bufferSize, format, std::strlen(format))};
+//   ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xfeedface),
+//       "Unknown 'C' edit descriptor in FORMAT");
+// }
 
 //------------------------------------------------------------------------------
 /// Test buffer overwrites with Output* functions
diff --git a/flang/unittests/Runtime/Stop.cpp b/flang/unittests/Runtime/Stop.cpp
index b13602eaee5ea..24c78251ea697 100644
--- a/flang/unittests/Runtime/Stop.cpp
+++ b/flang/unittests/Runtime/Stop.cpp
@@ -32,24 +32,24 @@ TEST(TestProgramEnd, StopTestNoStopMessage) {
       RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-TEST(TestProgramEnd, StopMessageTest) {
-  static const char *message{"bye bye"};
-  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-                  /*isErrorStop=*/false, /*quiet=*/false),
-      testing::ExitedWithCode(EXIT_SUCCESS), "Fortran STOP: bye bye");
-
-  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-                  /*isErrorStop=*/false, /*quiet=*/true),
-      testing::ExitedWithCode(EXIT_SUCCESS), "");
-
-  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-                  /*isErrorStop=*/true, /*quiet=*/false),
-      testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
-
-  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-                  /*isErrorStop=*/true, /*quiet=*/true),
-      testing::ExitedWithCode(EXIT_FAILURE), "");
-}
+// TEST(TestProgramEnd, StopMessageTest) {
+//   static const char *message{"bye bye"};
+//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+//                   /*isErrorStop=*/false, /*quiet=*/false),
+//       testing::ExitedWithCode(EXIT_SUCCESS), "Fortran STOP: bye bye");
+
+//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+//                   /*isErrorStop=*/false, /*quiet=*/true),
+//       testing::ExitedWithCode(EXIT_SUCCESS), "");
+
+//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+//                   /*isErrorStop=*/true, /*quiet=*/false),
+//       testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
+
+//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+//                   /*isErrorStop=*/true, /*quiet=*/true),
+//       testing::ExitedWithCode(EXIT_FAILURE), "");
+// }
 
 TEST(TestProgramEnd, NoStopMessageTest) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
diff --git a/flang/unittests/Runtime/TemporaryStack.cpp b/flang/unittests/Runtime/TemporaryStack.cpp
index 0a9344969ca6b..8b9aac99309ad 100644
--- a/flang/unittests/Runtime/TemporaryStack.cpp
+++ b/flang/unittests/Runtime/TemporaryStack.cpp
@@ -87,86 +87,86 @@ static unsigned max(unsigned x, unsigned y) {
   return y;
 }
 
-TEST(TemporaryStack, ValueStackMultiSize) {
-  constexpr unsigned numToTest = 42;
-  const TypeCode code{CFI_type_int32_t};
-  constexpr size_t elementBytes = 4;
-  SubscriptValue extent[CFI_MAX_RANK];
-
-  std::vector<OwningPtr<Descriptor>> inputDescriptors;
-  inputDescriptors.reserve(numToTest);
-
-  void *storage = RTNAME(CreateValueStack)(__FILE__, __LINE__);
-  ASSERT_NE(storage, nullptr);
-
-  // create descriptors with and without adendums
-  auto getAdendum = [](unsigned i) { return i % 2; };
-  // create descriptors with varying ranks
-  auto getRank = [](unsigned i) { return max(i % 8, 1); };
-
-  // push descriptors of varying sizes and contents
-  for (unsigned i = 0; i < numToTest; ++i) {
-    const bool adendum = getAdendum(i);
-    const size_t rank = getRank(i);
-    for (unsigned dim = 0; dim < rank; ++dim) {
-      extent[dim] = ((i + dim) % 8) + 1;
-    }
-
-    const OwningPtr<Descriptor> &desc =
-        inputDescriptors.emplace_back(Descriptor::Create(code, elementBytes,
-            nullptr, rank, extent, CFI_attribute_allocatable, adendum));
-
-    // Descriptor::Establish doesn't initialise the extents if baseaddr is null
-    for (unsigned dim = 0; dim < rank; ++dim) {
-      Fortran::ISO::CFI_dim_t &boxDims = desc->raw().dim[dim];
-      boxDims.lower_bound = 1;
-      boxDims.extent = extent[dim];
-      boxDims.sm = elementBytes;
-    }
-    desc->Allocate();
-
-    // fill the array with some data to test
-    for (uint32_t i = 0; i < desc->Elements(); ++i) {
-      uint32_t *data = static_cast<uint32_t *>(desc->raw().base_addr);
-      ASSERT_NE(data, nullptr);
-      data[i] = i;
-    }
-
-    RTNAME(PushValue)(storage, *desc.get());
-  }
-
-  const TypeCode boolCode{CFI_type_Bool};
-  // peek and test each descriptor
-  for (unsigned i = 0; i < numToTest; ++i) {
-    const OwningPtr<Descriptor> &input = inputDescriptors[i];
-    const bool adendum = getAdendum(i);
-    const size_t rank = getRank(i);
-
-    // buffer to return the descriptor into
-    OwningPtr<Descriptor> out = Descriptor::Create(
-        boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
-
-    (void)input;
-    RTNAME(ValueAt)(storage, i, *out.get());
-    descriptorAlmostEqual(*input, *out);
-  }
-
-  // pop and test each descriptor
-  for (unsigned i = numToTest; i > 0; --i) {
-    const OwningPtr<Descriptor> &input = inputDescriptors[i - 1];
-    const bool adendum = getAdendum(i - 1);
-    const size_t rank = getRank(i - 1);
-
-    // buffer to return the descriptor into
-    OwningPtr<Descriptor> out = Descriptor::Create(
-        boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
-
-    RTNAME(PopValue)(storage, *out.get());
-    descriptorAlmostEqual(*input, *out);
-  }
-
-  RTNAME(DestroyValueStack)(storage);
-}
+// TEST(TemporaryStack, ValueStackMultiSize) {
+//   constexpr unsigned numToTest = 42;
+//   const TypeCode code{CFI_type_int32_t};
+//   constexpr size_t elementBytes = 4;
+//   SubscriptValue extent[CFI_MAX_RANK];
+
+//   std::vector<OwningPtr<Descriptor>> inputDescriptors;
+//   inputDescriptors.reserve(numToTest);
+
+//   void *storage = RTNAME(CreateValueStack)(__FILE__, __LINE__);
+//   ASSERT_NE(storage, nullptr);
+
+//   // create descriptors with and without adendums
+//   auto getAdendum = [](unsigned i) { return i % 2; };
+//   // create descriptors with varying ranks
+//   auto getRank = [](unsigned i) { return max(i % 8, 1); };
+
+//   // push descriptors of varying sizes and contents
+//   for (unsigned i = 0; i < numToTest; ++i) {
+//     const bool adendum = getAdendum(i);
+//     const size_t rank = getRank(i);
+//     for (unsigned dim = 0; dim < rank; ++dim) {
+//       extent[dim] = ((i + dim) % 8) + 1;
+//     }
+
+//     const OwningPtr<Descriptor> &desc =
+//         inputDescriptors.emplace_back(Descriptor::Create(code, elementBytes,
+//             nullptr, rank, extent, CFI_attribute_allocatable, adendum));
+
+//     // Descriptor::Establish doesn't initialise the extents if baseaddr is null
+//     for (unsigned dim = 0; dim < rank; ++dim) {
+//       Fortran::ISO::CFI_dim_t &boxDims = desc->raw().dim[dim];
+//       boxDims.lower_bound = 1;
+//       boxDims.extent = extent[dim];
+//       boxDims.sm = elementBytes;
+//     }
+//     desc->Allocate();
+
+//     // fill the array with some data to test
+//     for (uint32_t i = 0; i < desc->Elements(); ++i) {
+//       uint32_t *data = static_cast<uint32_t *>(desc->raw().base_addr);
+//       ASSERT_NE(data, nullptr);
+//       data[i] = i;
+//     }
+
+//     RTNAME(PushValue)(storage, *desc.get());
+//   }
+
+//   const TypeCode boolCode{CFI_type_Bool};
+//   // peek and test each descriptor
+//   for (unsigned i = 0; i < numToTest; ++i) {
+//     const OwningPtr<Descriptor> &input = inputDescriptors[i];
+//     const bool adendum = getAdendum(i);
+//     const size_t rank = getRank(i);
+
+//     // buffer to return the descriptor into
+//     OwningPtr<Descriptor> out = Descriptor::Create(
+//         boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
+
+//     (void)input;
+//     RTNAME(ValueAt)(storage, i, *out.get());
+//     descriptorAlmostEqual(*input, *out);
+//   }
+
+//   // pop and test each descriptor
+//   for (unsigned i = numToTest; i > 0; --i) {
+//     const OwningPtr<Descriptor> &input = inputDescriptors[i - 1];
+//     const bool adendum = getAdendum(i - 1);
+//     const size_t rank = getRank(i - 1);
+
+//     // buffer to return the descriptor into
+//     OwningPtr<Descriptor> out = Descriptor::Create(
+//         boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
+
+//     RTNAME(PopValue)(storage, *out.get());
+//     descriptorAlmostEqual(*input, *out);
+//   }
+
+//   RTNAME(DestroyValueStack)(storage);
+// }
 
 TEST(TemporaryStack, DescriptorStackBasic) {
   const TypeCode code{CFI_type_Bool};

>From f2f96df7d753138c47c34096603f7e10d9484cb4 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 22:24:32 +0300
Subject: [PATCH 09/11] Limit CI down to flang

---
 .ci/generate-buildkite-pipeline-premerge | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.ci/generate-buildkite-pipeline-premerge b/.ci/generate-buildkite-pipeline-premerge
index 78a9cb77ff7d9..e36b91e6bf066 100755
--- a/.ci/generate-buildkite-pipeline-premerge
+++ b/.ci/generate-buildkite-pipeline-premerge
@@ -147,6 +147,11 @@ function exclude-windows() {
     libc)                ;; # no Windows support
     lldb)                ;; # tests failing
     bolt)                ;; # tests are not supported yet
+    clang)               ;;
+    llvm)                ;;
+    clang-tools-extra)   ;;
+    lld)                 ;;
+    polly)               ;;
     *)
       echo "${project}"
     ;;
@@ -187,6 +192,9 @@ function check-targets() {
     libclc)
       echo "check-all"
     ;;
+    mlir);;
+    clang);;
+    llvm);;
     *)
       echo "check-${project}"
     ;;

>From 3110b74e1c8237a079139f6edb3038ac113889a3 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 22:36:48 +0300
Subject: [PATCH 10/11] Revert "Disable a bunch of flang tests"

This reverts commit 1c785a63d029dc55fc06ec236e55983729767e2f.
---
 .../Optimizer/Builder/ComplexTest.cpp         |  44 ++--
 .../Optimizer/Builder/DoLoopHelperTest.cpp    |  30 +--
 .../Optimizer/Builder/FIRBuilderTest.cpp      |  12 +-
 .../Optimizer/Builder/HLFIRToolsTest.cpp      |  64 +++---
 .../Builder/Runtime/CharacterTest.cpp         |  22 +-
 .../Optimizer/Builder/Runtime/CommandTest.cpp |  12 +-
 .../Builder/Runtime/ReductionTest.cpp         |  42 ++--
 flang/unittests/Optimizer/FIRTypesTest.cpp    |  54 ++---
 .../Optimizer/FortranVariableTest.cpp         |  44 ++--
 .../unittests/Optimizer/InternalNamesTest.cpp |  64 +++---
 flang/unittests/Runtime/CharacterTest.cpp     |  96 ++++-----
 flang/unittests/Runtime/CommandTest.cpp       |  74 +++----
 flang/unittests/Runtime/Complex.cpp           |  34 +--
 flang/unittests/Runtime/ExternalIOTest.cpp    | 194 +++++++++---------
 flang/unittests/Runtime/Format.cpp            |  24 +--
 flang/unittests/Runtime/ListInputTest.cpp     |  58 +++---
 flang/unittests/Runtime/MiscIntrinsic.cpp     |  36 ++--
 flang/unittests/Runtime/Numeric.cpp           | 120 +++++------
 .../unittests/Runtime/NumericalFormatTest.cpp |  30 +--
 flang/unittests/Runtime/Pointer.cpp           |  38 ++--
 flang/unittests/Runtime/RuntimeCrashTest.cpp  |  18 +-
 flang/unittests/Runtime/Stop.cpp              |  36 ++--
 flang/unittests/Runtime/TemporaryStack.cpp    | 160 +++++++--------
 23 files changed, 653 insertions(+), 653 deletions(-)

diff --git a/flang/unittests/Optimizer/Builder/ComplexTest.cpp b/flang/unittests/Optimizer/Builder/ComplexTest.cpp
index b17ef9ef2f348..17171512470ac 100644
--- a/flang/unittests/Optimizer/Builder/ComplexTest.cpp
+++ b/flang/unittests/Optimizer/Builder/ComplexTest.cpp
@@ -62,30 +62,30 @@ struct ComplexTest : public testing::Test {
   mlir::Value rFour;
 };
 
-// TEST_F(ComplexTest, verifyTypes) {
-//   mlir::Value cVal1 = helper->createComplex(complexTy1, rOne, rTwo);
-//   mlir::Value cVal2 = helper->createComplex(4, rOne, rTwo);
-//   EXPECT_TRUE(fir::isa_complex(cVal1.getType()));
-//   EXPECT_TRUE(fir::isa_complex(cVal2.getType()));
-//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal1)));
-//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal2)));
+TEST_F(ComplexTest, verifyTypes) {
+  mlir::Value cVal1 = helper->createComplex(complexTy1, rOne, rTwo);
+  mlir::Value cVal2 = helper->createComplex(4, rOne, rTwo);
+  EXPECT_TRUE(fir::isa_complex(cVal1.getType()));
+  EXPECT_TRUE(fir::isa_complex(cVal2.getType()));
+  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal1)));
+  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal2)));
 
-//   mlir::Value real1 = helper->extractComplexPart(cVal1, /*isImagPart=*/false);
-//   mlir::Value imag1 = helper->extractComplexPart(cVal1, /*isImagPart=*/true);
-//   mlir::Value real2 = helper->extractComplexPart(cVal2, /*isImagPart=*/false);
-//   mlir::Value imag2 = helper->extractComplexPart(cVal2, /*isImagPart=*/true);
-//   EXPECT_EQ(realTy1, real1.getType());
-//   EXPECT_EQ(realTy1, imag1.getType());
-//   EXPECT_EQ(realTy1, real2.getType());
-//   EXPECT_EQ(realTy1, imag2.getType());
+  mlir::Value real1 = helper->extractComplexPart(cVal1, /*isImagPart=*/false);
+  mlir::Value imag1 = helper->extractComplexPart(cVal1, /*isImagPart=*/true);
+  mlir::Value real2 = helper->extractComplexPart(cVal2, /*isImagPart=*/false);
+  mlir::Value imag2 = helper->extractComplexPart(cVal2, /*isImagPart=*/true);
+  EXPECT_EQ(realTy1, real1.getType());
+  EXPECT_EQ(realTy1, imag1.getType());
+  EXPECT_EQ(realTy1, real2.getType());
+  EXPECT_EQ(realTy1, imag2.getType());
 
-//   mlir::Value cVal3 =
-//       helper->insertComplexPart(cVal1, rThree, /*isImagPart=*/false);
-//   mlir::Value cVal4 =
-//       helper->insertComplexPart(cVal3, rFour, /*isImagPart=*/true);
-//   EXPECT_TRUE(fir::isa_complex(cVal4.getType()));
-//   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal4)));
-// }
+  mlir::Value cVal3 =
+      helper->insertComplexPart(cVal1, rThree, /*isImagPart=*/false);
+  mlir::Value cVal4 =
+      helper->insertComplexPart(cVal3, rFour, /*isImagPart=*/true);
+  EXPECT_TRUE(fir::isa_complex(cVal4.getType()));
+  EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal4)));
+}
 
 TEST_F(ComplexTest, verifyConvertWithSemantics) {
   auto loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp b/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
index 9da6cde3e1d1e..d0a9342914a39 100644
--- a/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
+++ b/flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp
@@ -69,19 +69,19 @@ TEST_F(DoLoopHelperTest, createLoopWithLowerAndUpperBound) {
   checkConstantValue(loop.getStep(), 1);
 }
 
-// TEST_F(DoLoopHelperTest, createLoopWithStep) {
-//   auto firBuilder = getBuilder();
-//   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
+TEST_F(DoLoopHelperTest, createLoopWithStep) {
+  auto firBuilder = getBuilder();
+  fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 
-//   auto lb = firBuilder.createIntegerConstant(
-//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
-//   auto ub = firBuilder.createIntegerConstant(
-//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
-//   auto step = firBuilder.createIntegerConstant(
-//       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 2);
-//   auto loop = helper.createLoop(
-//       lb, ub, step, [&](fir::FirOpBuilder &, mlir::Value index) {});
-//   checkConstantValue(loop.getLowerBound(), 1);
-//   checkConstantValue(loop.getUpperBound(), 20);
-//   checkConstantValue(loop.getStep(), 2);
-// }
+  auto lb = firBuilder.createIntegerConstant(
+      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
+  auto ub = firBuilder.createIntegerConstant(
+      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
+  auto step = firBuilder.createIntegerConstant(
+      firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 2);
+  auto loop = helper.createLoop(
+      lb, ub, step, [&](fir::FirOpBuilder &, mlir::Value index) {});
+  checkConstantValue(loop.getLowerBound(), 1);
+  checkConstantValue(loop.getUpperBound(), 20);
+  checkConstantValue(loop.getStep(), 2);
+}
diff --git a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
index 3f18ea073711f..e5e5454ee88ad 100644
--- a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
+++ b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp
@@ -154,12 +154,12 @@ TEST_F(FIRBuilderTest, createRealZeroConstant) {
       0u, mlir::cast<FloatAttr>(cstOp.getValue()).getValue().convertToDouble());
 }
 
-// TEST_F(FIRBuilderTest, createBool) {
-//   auto builder = getBuilder();
-//   auto loc = builder.getUnknownLoc();
-//   auto b = builder.createBool(loc, false);
-//   checkIntegerConstant(b, builder.getIntegerType(1), 0);
-// }
+TEST_F(FIRBuilderTest, createBool) {
+  auto builder = getBuilder();
+  auto loc = builder.getUnknownLoc();
+  auto b = builder.createBool(loc, false);
+  checkIntegerConstant(b, builder.getIntegerType(1), 0);
+}
 
 TEST_F(FIRBuilderTest, getVarLenSeqTy) {
   auto builder = getBuilder();
diff --git a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
index 616045f275e16..1858b276f1fc3 100644
--- a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
+++ b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
@@ -126,38 +126,38 @@ TEST_F(HLFIRToolsTest, testScalarCharRoundTrip) {
   EXPECT_FALSE(scalarCharEntity.isValue());
 }
 
-// TEST_F(HLFIRToolsTest, testArrayCharRoundTrip) {
-//   auto &builder = getBuilder();
-//   mlir::Location loc = getLoc();
-//   llvm::SmallVector<mlir::Value> extents{
-//       createConstant(20), createConstant(30)};
-//   llvm::SmallVector<mlir::Value> lbounds{
-//       createConstant(-1), createConstant(-2)};
-//   mlir::Value len = createConstant(42);
-//   mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
-//   mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
-//   mlir::Type arrayCharType = builder.getRefType(seqCharType);
-//   mlir::Value arrayCharAddr = builder.create<fir::UndefOp>(loc, arrayCharType);
-//   fir::CharArrayBoxValue arrayChar{arrayCharAddr, len, extents, lbounds};
-//   hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
-//   auto [arrayCharResult, cleanup] =
-//       hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
-//   auto *res = arrayCharResult.getBoxOf<fir::CharArrayBoxValue>();
-//   EXPECT_FALSE(cleanup.has_value());
-//   ASSERT_NE(res, nullptr);
-//   // gtest has a terrible time printing mlir::Value in case of failing
-//   // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
-//   EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getFirBase());
-//   EXPECT_TRUE(res->getLen() == arrayChar.getLen());
-//   ASSERT_EQ(res->getExtents().size(), arrayChar.getExtents().size());
-//   for (unsigned i = 0; i < arrayChar.getExtents().size(); ++i)
-//     EXPECT_TRUE(res->getExtents()[i] == arrayChar.getExtents()[i]);
-//   ASSERT_EQ(res->getLBounds().size(), arrayChar.getLBounds().size());
-//   for (unsigned i = 0; i < arrayChar.getLBounds().size(); ++i)
-//     EXPECT_TRUE(res->getLBounds()[i] == arrayChar.getLBounds()[i]);
-//   EXPECT_TRUE(arrayCharEntity.isVariable());
-//   EXPECT_FALSE(arrayCharEntity.isValue());
-// }
+TEST_F(HLFIRToolsTest, testArrayCharRoundTrip) {
+  auto &builder = getBuilder();
+  mlir::Location loc = getLoc();
+  llvm::SmallVector<mlir::Value> extents{
+      createConstant(20), createConstant(30)};
+  llvm::SmallVector<mlir::Value> lbounds{
+      createConstant(-1), createConstant(-2)};
+  mlir::Value len = createConstant(42);
+  mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
+  mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
+  mlir::Type arrayCharType = builder.getRefType(seqCharType);
+  mlir::Value arrayCharAddr = builder.create<fir::UndefOp>(loc, arrayCharType);
+  fir::CharArrayBoxValue arrayChar{arrayCharAddr, len, extents, lbounds};
+  hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
+  auto [arrayCharResult, cleanup] =
+      hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
+  auto *res = arrayCharResult.getBoxOf<fir::CharArrayBoxValue>();
+  EXPECT_FALSE(cleanup.has_value());
+  ASSERT_NE(res, nullptr);
+  // gtest has a terrible time printing mlir::Value in case of failing
+  // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
+  EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getFirBase());
+  EXPECT_TRUE(res->getLen() == arrayChar.getLen());
+  ASSERT_EQ(res->getExtents().size(), arrayChar.getExtents().size());
+  for (unsigned i = 0; i < arrayChar.getExtents().size(); ++i)
+    EXPECT_TRUE(res->getExtents()[i] == arrayChar.getExtents()[i]);
+  ASSERT_EQ(res->getLBounds().size(), arrayChar.getLBounds().size());
+  for (unsigned i = 0; i < arrayChar.getLBounds().size(); ++i)
+    EXPECT_TRUE(res->getLBounds()[i] == arrayChar.getLBounds()[i]);
+  EXPECT_TRUE(arrayCharEntity.isVariable());
+  EXPECT_FALSE(arrayCharEntity.isValue());
+}
 
 TEST_F(HLFIRToolsTest, testArrayCharBoxRoundTrip) {
   auto &builder = getBuilder();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
index 18f7dd0743a73..315f8c80dc33f 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp
@@ -113,17 +113,17 @@ TEST_F(RuntimeCallTest, genIndexTest) {
   checkGenIndex(*firBuilder, "_FortranAIndex4", 4);
 }
 
-// TEST_F(RuntimeCallTest, genIndexDescriptorTest) {
-//   auto loc = firBuilder->getUnknownLoc();
-//   mlir::Value resultBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-//   mlir::Value stringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-//   mlir::Value substringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
-//   mlir::Value backOpt = firBuilder->create<fir::UndefOp>(loc, boxTy);
-//   mlir::Value kind = firBuilder->create<fir::UndefOp>(loc, i32Ty);
-//   fir::runtime::genIndexDescriptor(
-//       *firBuilder, loc, resultBox, stringBox, substringBox, backOpt, kind);
-//   checkCallOpFromResultBox(resultBox, "_FortranAIndex", 5);
-// }
+TEST_F(RuntimeCallTest, genIndexDescriptorTest) {
+  auto loc = firBuilder->getUnknownLoc();
+  mlir::Value resultBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+  mlir::Value stringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+  mlir::Value substringBox = firBuilder->create<fir::UndefOp>(loc, boxTy);
+  mlir::Value backOpt = firBuilder->create<fir::UndefOp>(loc, boxTy);
+  mlir::Value kind = firBuilder->create<fir::UndefOp>(loc, i32Ty);
+  fir::runtime::genIndexDescriptor(
+      *firBuilder, loc, resultBox, stringBox, substringBox, backOpt, kind);
+  checkCallOpFromResultBox(resultBox, "_FortranAIndex", 5);
+}
 
 TEST_F(RuntimeCallTest, genRepeatTest) {
   auto loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
index 57347e56b4c61..58a151447d5b4 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/CommandTest.cpp
@@ -10,12 +10,12 @@
 #include "RuntimeCallTestBase.h"
 #include "gtest/gtest.h"
 
-// TEST_F(RuntimeCallTest, genCommandArgumentCountTest) {
-//   mlir::Location loc = firBuilder->getUnknownLoc();
-//   mlir::Value result = fir::runtime::genCommandArgumentCount(*firBuilder, loc);
-//   checkCallOp(result.getDefiningOp(), "_FortranAArgumentCount", /*nbArgs=*/0,
-//       /*addLocArgs=*/false);
-// }
+TEST_F(RuntimeCallTest, genCommandArgumentCountTest) {
+  mlir::Location loc = firBuilder->getUnknownLoc();
+  mlir::Value result = fir::runtime::genCommandArgumentCount(*firBuilder, loc);
+  checkCallOp(result.getDefiningOp(), "_FortranAArgumentCount", /*nbArgs=*/0,
+      /*addLocArgs=*/false);
+}
 
 TEST_F(RuntimeCallTest, genGetCommandArgument) {
   mlir::Location loc = firBuilder->getUnknownLoc();
diff --git a/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp b/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
index 994e113da70e4..a4006c6b59c12 100644
--- a/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
+++ b/flang/unittests/Optimizer/Builder/Runtime/ReductionTest.cpp
@@ -52,15 +52,15 @@ TEST_F(RuntimeCallTest, genCountTest) {
   checkCallOp(count.getDefiningOp(), "_FortranACount", 2);
 }
 
-// TEST_F(RuntimeCallTest, genCountDimTest) {
-//   mlir::Location loc = firBuilder->getUnknownLoc();
-//   mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-//   mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-//   mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-//   mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-//   fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
-//   checkCallOpFromResultBox(result, "_FortranACountDim", 4);
-// }
+TEST_F(RuntimeCallTest, genCountDimTest) {
+  mlir::Location loc = firBuilder->getUnknownLoc();
+  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
+  checkCallOpFromResultBox(result, "_FortranACountDim", 4);
+}
 
 void testGenMaxVal(
     fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
@@ -120,14 +120,14 @@ TEST_F(RuntimeCallTest, genParityTest) {
   checkCallOp(parity.getDefiningOp(), "_FortranAParity", 2);
 }
 
-// TEST_F(RuntimeCallTest, genParityDescriptorTest) {
-//   mlir::Location loc = firBuilder->getUnknownLoc();
-//   mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-//   mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
-//   mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
-//   fir::runtime::genParityDescriptor(*firBuilder, loc, result, mask, dim);
-//   checkCallOpFromResultBox(result, "_FortranAParityDim", 3);
-// }
+TEST_F(RuntimeCallTest, genParityDescriptorTest) {
+  mlir::Location loc = firBuilder->getUnknownLoc();
+  mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+  mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
+  mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
+  fir::runtime::genParityDescriptor(*firBuilder, loc, result, mask, dim);
+  checkCallOpFromResultBox(result, "_FortranAParityDim", 3);
+}
 
 void testGenSum(
     fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
@@ -349,10 +349,10 @@ TEST_F(RuntimeCallTest, genMaxvalCharTest) {
       *firBuilder, fir::runtime::genMaxvalChar, "_FortranAMaxvalCharacter", 3);
 }
 
-// TEST_F(RuntimeCallTest, genMinvalCharTest) {
-//   checkGenMxxvalChar(
-//       *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
-// }
+TEST_F(RuntimeCallTest, genMinvalCharTest) {
+  checkGenMxxvalChar(
+      *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
+}
 
 void checkGen4argsDim(fir::FirOpBuilder &builder,
     void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
diff --git a/flang/unittests/Optimizer/FIRTypesTest.cpp b/flang/unittests/Optimizer/FIRTypesTest.cpp
index 5ea621eebcdd4..238aa6939d5df 100644
--- a/flang/unittests/Optimizer/FIRTypesTest.cpp
+++ b/flang/unittests/Optimizer/FIRTypesTest.cpp
@@ -125,33 +125,33 @@ TEST_F(FIRTypesTest, isUnlimitedPolymorphicTypeTest) {
 }
 
 // Test fir::isBoxedRecordType from flang/Optimizer/Dialect/FIRType.h.
-// TEST_F(FIRTypesTest, isBoxedRecordType) {
-//   mlir::Type recTy = fir::RecordType::get(&context, "dt");
-//   mlir::Type seqRecTy =
-//       fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, recTy);
-//   mlir::Type ty = fir::BoxType::get(recTy);
-//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
-//   EXPECT_TRUE(fir::isBoxedRecordType(fir::ReferenceType::get(ty)));
-
-//   // TYPE(T), ALLOCATABLE
-//   ty = fir::BoxType::get(fir::HeapType::get(recTy));
-//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-//   // TYPE(T), POINTER
-//   ty = fir::BoxType::get(fir::PointerType::get(recTy));
-//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-//   // TYPE(T), DIMENSION(10)
-//   ty = fir::BoxType::get(fir::SequenceType::get({10}, recTy));
-//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-//   // TYPE(T), DIMENSION(:)
-//   ty = fir::BoxType::get(seqRecTy);
-//   EXPECT_TRUE(fir::isBoxedRecordType(ty));
-
-//   EXPECT_FALSE(fir::isBoxedRecordType(fir::BoxType::get(
-//       fir::ReferenceType::get(mlir::IntegerType::get(&context, 32)))));
-// }
+TEST_F(FIRTypesTest, isBoxedRecordType) {
+  mlir::Type recTy = fir::RecordType::get(&context, "dt");
+  mlir::Type seqRecTy =
+      fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, recTy);
+  mlir::Type ty = fir::BoxType::get(recTy);
+  EXPECT_TRUE(fir::isBoxedRecordType(ty));
+  EXPECT_TRUE(fir::isBoxedRecordType(fir::ReferenceType::get(ty)));
+
+  // TYPE(T), ALLOCATABLE
+  ty = fir::BoxType::get(fir::HeapType::get(recTy));
+  EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+  // TYPE(T), POINTER
+  ty = fir::BoxType::get(fir::PointerType::get(recTy));
+  EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+  // TYPE(T), DIMENSION(10)
+  ty = fir::BoxType::get(fir::SequenceType::get({10}, recTy));
+  EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+  // TYPE(T), DIMENSION(:)
+  ty = fir::BoxType::get(seqRecTy);
+  EXPECT_TRUE(fir::isBoxedRecordType(ty));
+
+  EXPECT_FALSE(fir::isBoxedRecordType(fir::BoxType::get(
+      fir::ReferenceType::get(mlir::IntegerType::get(&context, 32)))));
+}
 
 // Test fir::isScalarBoxedRecordType from flang/Optimizer/Dialect/FIRType.h.
 TEST_F(FIRTypesTest, isScalarBoxedRecordType) {
diff --git a/flang/unittests/Optimizer/FortranVariableTest.cpp b/flang/unittests/Optimizer/FortranVariableTest.cpp
index ae48cdb18533e..87efb624735cf 100644
--- a/flang/unittests/Optimizer/FortranVariableTest.cpp
+++ b/flang/unittests/Optimizer/FortranVariableTest.cpp
@@ -42,29 +42,29 @@ struct FortranVariableTest : public testing::Test {
   std::unique_ptr<mlir::OpBuilder> builder;
 };
 
-// TEST_F(FortranVariableTest, SimpleScalar) {
-//   mlir::Location loc = getLoc();
-//   mlir::Type eleType = mlir::FloatType::getF32(&context);
-//   mlir::Value addr = builder->create<fir::AllocaOp>(loc, eleType);
-//   auto name = mlir::StringAttr::get(&context, "x");
-//   auto declare = builder->create<fir::DeclareOp>(loc, addr.getType(), addr,
-//       /*shape=*/mlir::Value{}, /*typeParams=*/std::nullopt,
-//       /*dummy_scope=*/nullptr, name,
-//       /*fortran_attrs=*/fir::FortranVariableFlagsAttr{},
-//       /*data_attr=*/cuf::DataAttributeAttr{});
+TEST_F(FortranVariableTest, SimpleScalar) {
+  mlir::Location loc = getLoc();
+  mlir::Type eleType = mlir::FloatType::getF32(&context);
+  mlir::Value addr = builder->create<fir::AllocaOp>(loc, eleType);
+  auto name = mlir::StringAttr::get(&context, "x");
+  auto declare = builder->create<fir::DeclareOp>(loc, addr.getType(), addr,
+      /*shape=*/mlir::Value{}, /*typeParams=*/std::nullopt,
+      /*dummy_scope=*/nullptr, name,
+      /*fortran_attrs=*/fir::FortranVariableFlagsAttr{},
+      /*data_attr=*/cuf::DataAttributeAttr{});
 
-//   fir::FortranVariableOpInterface fortranVariable = declare;
-//   EXPECT_FALSE(fortranVariable.isArray());
-//   EXPECT_FALSE(fortranVariable.isCharacter());
-//   EXPECT_FALSE(fortranVariable.isPointer());
-//   EXPECT_FALSE(fortranVariable.isAllocatable());
-//   EXPECT_FALSE(fortranVariable.hasExplicitCharLen());
-//   EXPECT_EQ(fortranVariable.getElementType(), eleType);
-//   EXPECT_EQ(fortranVariable.getElementOrSequenceType(),
-//       fortranVariable.getElementType());
-//   EXPECT_NE(fortranVariable.getBase(), addr);
-//   EXPECT_EQ(fortranVariable.getBase().getType(), addr.getType());
-// }
+  fir::FortranVariableOpInterface fortranVariable = declare;
+  EXPECT_FALSE(fortranVariable.isArray());
+  EXPECT_FALSE(fortranVariable.isCharacter());
+  EXPECT_FALSE(fortranVariable.isPointer());
+  EXPECT_FALSE(fortranVariable.isAllocatable());
+  EXPECT_FALSE(fortranVariable.hasExplicitCharLen());
+  EXPECT_EQ(fortranVariable.getElementType(), eleType);
+  EXPECT_EQ(fortranVariable.getElementOrSequenceType(),
+      fortranVariable.getElementType());
+  EXPECT_NE(fortranVariable.getBase(), addr);
+  EXPECT_EQ(fortranVariable.getBase().getType(), addr.getType());
+}
 
 TEST_F(FortranVariableTest, CharacterScalar) {
   mlir::Location loc = getLoc();
diff --git a/flang/unittests/Optimizer/InternalNamesTest.cpp b/flang/unittests/Optimizer/InternalNamesTest.cpp
index 470791d41541a..058bbeef9b007 100644
--- a/flang/unittests/Optimizer/InternalNamesTest.cpp
+++ b/flang/unittests/Optimizer/InternalNamesTest.cpp
@@ -88,38 +88,38 @@ TEST(InternalNamesTest, doTypeTest) {
   ASSERT_EQ(actual, expectedMangledName);
 }
 
-// TEST(InternalNamesTest, doIntrinsicTypeDescriptorTest) {
-//   using IntrinsicType = fir::NameUniquer::IntrinsicType;
-//   std::string actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::REAL, 42);
-//   std::string expectedMangledName = "_QYIrealK42";
-//   ASSERT_EQ(actual, expectedMangledName);
-
-//   actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::REAL, {});
-//   expectedMangledName = "_QYIrealK0";
-//   ASSERT_EQ(actual, expectedMangledName);
-
-//   actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::INTEGER, 3);
-//   expectedMangledName = "_QYIintegerK3";
-//   ASSERT_EQ(actual, expectedMangledName);
-
-//   actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::LOGICAL, 2);
-//   expectedMangledName = "_QYIlogicalK2";
-//   ASSERT_EQ(actual, expectedMangledName);
-
-//   actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::CHARACTER, 4);
-//   expectedMangledName = "_QYIcharacterK4";
-//   ASSERT_EQ(actual, expectedMangledName);
-
-//   actual = NameUniquer::doIntrinsicTypeDescriptor(
-//       {}, {}, 0, IntrinsicType::COMPLEX, 4);
-//   expectedMangledName = "_QYIcomplexK4";
-//   ASSERT_EQ(actual, expectedMangledName);
-// }
+TEST(InternalNamesTest, doIntrinsicTypeDescriptorTest) {
+  using IntrinsicType = fir::NameUniquer::IntrinsicType;
+  std::string actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::REAL, 42);
+  std::string expectedMangledName = "_QYIrealK42";
+  ASSERT_EQ(actual, expectedMangledName);
+
+  actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::REAL, {});
+  expectedMangledName = "_QYIrealK0";
+  ASSERT_EQ(actual, expectedMangledName);
+
+  actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::INTEGER, 3);
+  expectedMangledName = "_QYIintegerK3";
+  ASSERT_EQ(actual, expectedMangledName);
+
+  actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::LOGICAL, 2);
+  expectedMangledName = "_QYIlogicalK2";
+  ASSERT_EQ(actual, expectedMangledName);
+
+  actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::CHARACTER, 4);
+  expectedMangledName = "_QYIcharacterK4";
+  ASSERT_EQ(actual, expectedMangledName);
+
+  actual = NameUniquer::doIntrinsicTypeDescriptor(
+      {}, {}, 0, IntrinsicType::COMPLEX, 4);
+  expectedMangledName = "_QYIcomplexK4";
+  ASSERT_EQ(actual, expectedMangledName);
+}
 
 TEST(InternalNamesTest, doDispatchTableTest) {
   std::string actual =
diff --git a/flang/unittests/Runtime/CharacterTest.cpp b/flang/unittests/Runtime/CharacterTest.cpp
index e9522fae9a2c8..e54fd8a5075f6 100644
--- a/flang/unittests/Runtime/CharacterTest.cpp
+++ b/flang/unittests/Runtime/CharacterTest.cpp
@@ -199,32 +199,32 @@ struct CharacterComparisonTests : public ::testing::Test {
 
 TYPED_TEST_SUITE(CharacterComparisonTests, CharacterTypes, );
 
-// TYPED_TEST(CharacterComparisonTests, CompareCharacters) {
-//   for (auto &[x, y, xBytes, yBytes, expect] : this->parameters) {
-//     int cmp{this->characterComparisonFunc(x, y, xBytes, yBytes)};
-//     TypeParam buf[2][8];
-//     std::memset(buf, 0, sizeof buf);
-//     std::memcpy(buf[0], x, xBytes);
-//     std::memcpy(buf[1], y, yBytes);
-//     ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
-//                            << y << "'(" << yBytes << "), got " << cmp
-//                            << ", should be " << expect << '\n';
-
-//     // Perform the same test with the parameters reversed and the difference
-//     // negated
-//     std::swap(x, y);
-//     std::swap(xBytes, yBytes);
-//     expect = -expect;
-
-//     cmp = this->characterComparisonFunc(x, y, xBytes, yBytes);
-//     std::memset(buf, 0, sizeof buf);
-//     std::memcpy(buf[0], x, xBytes);
-//     std::memcpy(buf[1], y, yBytes);
-//     ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
-//                            << y << "'(" << yBytes << "'), got " << cmp
-//                            << ", should be " << expect << '\n';
-//   }
-// }
+TYPED_TEST(CharacterComparisonTests, CompareCharacters) {
+  for (auto &[x, y, xBytes, yBytes, expect] : this->parameters) {
+    int cmp{this->characterComparisonFunc(x, y, xBytes, yBytes)};
+    TypeParam buf[2][8];
+    std::memset(buf, 0, sizeof buf);
+    std::memcpy(buf[0], x, xBytes);
+    std::memcpy(buf[1], y, yBytes);
+    ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
+                           << y << "'(" << yBytes << "), got " << cmp
+                           << ", should be " << expect << '\n';
+
+    // Perform the same test with the parameters reversed and the difference
+    // negated
+    std::swap(x, y);
+    std::swap(xBytes, yBytes);
+    expect = -expect;
+
+    cmp = this->characterComparisonFunc(x, y, xBytes, yBytes);
+    std::memset(buf, 0, sizeof buf);
+    std::memcpy(buf[0], x, xBytes);
+    std::memcpy(buf[1], y, yBytes);
+    ASSERT_EQ(cmp, expect) << "compare '" << x << "'(" << xBytes << ") to '"
+                           << y << "'(" << yBytes << "'), got " << cmp
+                           << ", should be " << expect << '\n';
+  }
+}
 
 // Test MIN() and MAX()
 struct ExtremumTestCase {
@@ -275,14 +275,14 @@ TYPED_TEST(ExtremumTests, MinTests) {
   RunExtremumTests<TypeParam>("MIN", RTNAME(CharacterMin), tests);
 }
 
-// TYPED_TEST(ExtremumTests, MaxTests) {
-//   static std::vector<ExtremumTestCase> tests{
-//       {{}, {"a"}, {"z"}, {"z"}},
-//       {{1}, {"zaa"}, {"aaaaa"}, {"zaa  "}},
-//       {{1, 1, 1}, {"aaaaa"}, {"aazaa"}, {"aazaa"}},
-//   };
-//   RunExtremumTests<TypeParam>("MAX", RTNAME(CharacterMax), tests);
-// }
+TYPED_TEST(ExtremumTests, MaxTests) {
+  static std::vector<ExtremumTestCase> tests{
+      {{}, {"a"}, {"z"}, {"z"}},
+      {{1}, {"zaa"}, {"aaaaa"}, {"zaa  "}},
+      {{1, 1, 1}, {"aaaaa"}, {"aazaa"}, {"aazaa"}},
+  };
+  RunExtremumTests<TypeParam>("MAX", RTNAME(CharacterMax), tests);
+}
 
 template <typename CHAR>
 void RunAllocationTest(const char *xRaw, const char *yRaw) {
@@ -373,20 +373,20 @@ TYPED_TEST(SearchTests, ScanTests) {
   RunSearchTests("SCAN", tests, std::get<SearchFunction<TypeParam>>(functions));
 }
 
-// TYPED_TEST(SearchTests, VerifyTests) {
-//   static SearchFunctions functions{
-//       RTNAME(Verify1), RTNAME(Verify2), RTNAME(Verify4)};
-//   static std::vector<SearchTestCase> tests{
-//       {"abc", "abc", false, 0},
-//       {"abc", "abc", true, 0},
-//       {"abc", "cde", false, 1},
-//       {"abc", "cde", true, 2},
-//       {"abc", "x", false, 1},
-//       {"", "x", false, 0},
-//   };
-//   RunSearchTests(
-//       "VERIFY", tests, std::get<SearchFunction<TypeParam>>(functions));
-// }
+TYPED_TEST(SearchTests, VerifyTests) {
+  static SearchFunctions functions{
+      RTNAME(Verify1), RTNAME(Verify2), RTNAME(Verify4)};
+  static std::vector<SearchTestCase> tests{
+      {"abc", "abc", false, 0},
+      {"abc", "abc", true, 0},
+      {"abc", "cde", false, 1},
+      {"abc", "cde", true, 2},
+      {"abc", "x", false, 1},
+      {"", "x", false, 0},
+  };
+  RunSearchTests(
+      "VERIFY", tests, std::get<SearchFunction<TypeParam>>(functions));
+}
 
 // Test REPEAT()
 template <typename CHAR> struct RepeatTests : public ::testing::Test {};
diff --git a/flang/unittests/Runtime/CommandTest.cpp b/flang/unittests/Runtime/CommandTest.cpp
index c67eb091d0b11..08daa4ba37f26 100644
--- a/flang/unittests/Runtime/CommandTest.cpp
+++ b/flang/unittests/Runtime/CommandTest.cpp
@@ -308,21 +308,21 @@ TEST_F(ZeroArguments, GetCommandArgument) {
 
 TEST_F(ZeroArguments, GetCommand) { CheckCommandValue(commandOnlyArgv, 1); }
 
-// TEST_F(ZeroArguments, ECLValidCommandAndPadSync) {
-//   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
-//   bool wait{true};
-//   OwningPtr<Descriptor> exitStat{EmptyIntDescriptor()};
-//   OwningPtr<Descriptor> cmdStat{EmptyIntDescriptor()};
-//   OwningPtr<Descriptor> cmdMsg{CharDescriptor("No change")};
-
-//   RTNAME(ExecuteCommandLine)
-//   (*command.get(), wait, exitStat.get(), cmdStat.get(), cmdMsg.get());
-
-//   std::string spaces(cmdMsg->ElementBytes(), ' ');
-//   CheckDescriptorEqInt<std::int64_t>(exitStat.get(), 0);
-//   CheckDescriptorEqInt<std::int64_t>(cmdStat.get(), 0);
-//   CheckDescriptorEqStr(cmdMsg.get(), "No change");
-// }
+TEST_F(ZeroArguments, ECLValidCommandAndPadSync) {
+  OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
+  bool wait{true};
+  OwningPtr<Descriptor> exitStat{EmptyIntDescriptor()};
+  OwningPtr<Descriptor> cmdStat{EmptyIntDescriptor()};
+  OwningPtr<Descriptor> cmdMsg{CharDescriptor("No change")};
+
+  RTNAME(ExecuteCommandLine)
+  (*command.get(), wait, exitStat.get(), cmdStat.get(), cmdMsg.get());
+
+  std::string spaces(cmdMsg->ElementBytes(), ' ');
+  CheckDescriptorEqInt<std::int64_t>(exitStat.get(), 0);
+  CheckDescriptorEqInt<std::int64_t>(cmdStat.get(), 0);
+  CheckDescriptorEqStr(cmdMsg.get(), "No change");
+}
 
 TEST_F(ZeroArguments, ECLValidCommandStatusSetSync) {
   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
@@ -404,14 +404,14 @@ TEST_F(ZeroArguments, ECLInvalidCommandParentNotTerminatedAsync) {
   CheckDescriptorEqStr(cmdMsg.get(), "No change");
 }
 
-// TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectSync) {
-//   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
+TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectSync) {
+  OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
 
-//   EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
-//       *command.get(), false, nullptr, nullptr, nullptr));
-//   EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
-//       *command.get(), true, nullptr, nullptr, nullptr));
-// }
+  EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
+      *command.get(), false, nullptr, nullptr, nullptr));
+  EXPECT_NO_FATAL_FAILURE(RTNAME(ExecuteCommandLine)(
+      *command.get(), true, nullptr, nullptr, nullptr));
+}
 
 TEST_F(ZeroArguments, ECLInvalidCommandAsyncDontAffectAsync) {
   OwningPtr<Descriptor> command{CharDescriptor("echo hi")};
@@ -560,18 +560,18 @@ TEST_F(SeveralArguments, GetCommand) {
   CheckMissingCommandValue("Missing argument");
 }
 
-// TEST_F(SeveralArguments, CommandErrMsgTooShort) {
-//   OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
-//   OwningPtr<Descriptor> length{EmptyIntDescriptor()};
-//   OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
+TEST_F(SeveralArguments, CommandErrMsgTooShort) {
+  OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
+  OwningPtr<Descriptor> length{EmptyIntDescriptor()};
+  OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
 
-//   EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), errMsg.get()), 0);
+  EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), errMsg.get()), 0);
 
-//   std::string spaces(value->ElementBytes(), ' ');
-//   CheckDescriptorEqStr(value.get(), spaces);
-//   CheckDescriptorEqInt<std::int64_t>(length.get(), 0);
-//   CheckDescriptorEqStr(errMsg.get(), "Mis");
-// }
+  std::string spaces(value->ElementBytes(), ' ');
+  CheckDescriptorEqStr(value.get(), spaces);
+  CheckDescriptorEqInt<std::int64_t>(length.get(), 0);
+  CheckDescriptorEqStr(errMsg.get(), "Mis");
+}
 
 TEST_F(SeveralArguments, GetCommandCanTakeNull) {
   EXPECT_GT(RTNAME(GetCommand)(nullptr, nullptr, nullptr), 0);
@@ -700,11 +700,11 @@ TEST_F(EnvironmentVariables, NoTrim) {
   }
 }
 
-// TEST_F(EnvironmentVariables, Empty) {
-//   if (EnableFineGrainedTests()) {
-//     CheckEnvVarValue("", "EMPTY");
-//   }
-// }
+TEST_F(EnvironmentVariables, Empty) {
+  if (EnableFineGrainedTests()) {
+    CheckEnvVarValue("", "EMPTY");
+  }
+}
 
 TEST_F(EnvironmentVariables, NoValueOrErrmsg) {
   ASSERT_EQ(std::getenv("DOESNT_EXIST"), nullptr)
diff --git a/flang/unittests/Runtime/Complex.cpp b/flang/unittests/Runtime/Complex.cpp
index f87b890c825d3..46f3ad2f2712b 100644
--- a/flang/unittests/Runtime/Complex.cpp
+++ b/flang/unittests/Runtime/Complex.cpp
@@ -133,23 +133,23 @@ TEST(Complex, cpowk) {
       cpowk(0.f + 1if, std::numeric_limits<std::int64_t>::min()), 1.f + 0if);
 }
 
-// TEST(Complex, zpowi) {
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 0), 1. + 0i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 1), 3. + 4i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 2), -7. + 24i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 3), -117. + 44i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 4), -527. - 336i);
-
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, -2), -0.0112 - 0.0384i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 10), -237. - 3116i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -10), -9.32293628 - 7.29848564i);
-
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 5), -38. + 41i);
-//   EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -5), -1.12183773 + 3.25291503i);
-
-//   EXPECT_COMPLEX_DOUBLE_EQ(
-//       zpowi(0. + 1i, std::numeric_limits<std::int32_t>::min()), 1. + 0i);
-// }
+TEST(Complex, zpowi) {
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 0), 1. + 0i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 1), 3. + 4i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 2), -7. + 24i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 3), -117. + 44i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, 4), -527. - 336i);
+
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(3. + 4i, -2), -0.0112 - 0.0384i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 10), -237. - 3116i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -10), -9.32293628 - 7.29848564i);
+
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(2. + 1i, 5), -38. + 41i);
+  EXPECT_COMPLEX_DOUBLE_EQ(zpowi(0.5 + 0.6i, -5), -1.12183773 + 3.25291503i);
+
+  EXPECT_COMPLEX_DOUBLE_EQ(
+      zpowi(0. + 1i, std::numeric_limits<std::int32_t>::min()), 1. + 0i);
+}
 
 TEST(Complex, zpowk) {
   EXPECT_COMPLEX_DOUBLE_EQ(zpowk(3. + 4i, 0), 1. + 0i);
diff --git a/flang/unittests/Runtime/ExternalIOTest.cpp b/flang/unittests/Runtime/ExternalIOTest.cpp
index 0f3da0784f9d4..13327964e12a4 100644
--- a/flang/unittests/Runtime/ExternalIOTest.cpp
+++ b/flang/unittests/Runtime/ExternalIOTest.cpp
@@ -585,103 +585,103 @@ TEST(ExternalIOTests, TestNonAvancingInput) {
       << "EndIoStatement() for Close";
 }
 
-// TEST(ExternalIOTests, TestWriteAfterNonAvancingInput) {
-//   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
-//   //   FORM='FORMATTED',STATUS='SCRATCH')
-//   auto *io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
-//   ASSERT_TRUE(IONAME(SetAccess)(io, "SEQUENTIAL", 10))
-//       << "SetAccess(SEQUENTIAL)";
-//   ASSERT_TRUE(IONAME(SetAction)(io, "READWRITE", 9)) << "SetAction(READWRITE)";
-//   ASSERT_TRUE(IONAME(SetForm)(io, "FORMATTED", 9)) << "SetForm(FORMATTED)";
-//   ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
-
-//   int unit{-1};
-//   ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for OpenNewUnit";
-
-//   // Write the file to be used for the input test.
-//   static constexpr std::string_view records[] = {"ABCDEFGHIJKLMNOPQRST"};
-//   static constexpr std::string_view fmt{"(A)"};
-//   for (const auto &record : records) {
-//     // WRITE(UNIT=unit,FMT=fmt) record
-//     io = IONAME(BeginExternalFormattedOutput)(
-//         fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-//     ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
-//         << "OutputAscii()";
-//     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//         << "EndIoStatement() for OutputAscii";
-//   }
-
-//   // REWIND(UNIT=unit)
-//   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for Rewind";
-
-//   struct TestItems {
-//     std::string item;
-//     int expectedIoStat;
-//     std::string expectedItemValue;
-//   };
-//   // Actual non advancing input IO test
-//   TestItems inputItems[]{
-//       {std::string(4, '+'), IostatOk, "ABCD"},
-//       {std::string(4, '+'), IostatOk, "EFGH"},
-//   };
-
-//   int j{0};
-//   for (auto &inputItem : inputItems) {
-//     // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
-//     io = IONAME(BeginExternalFormattedInput)(
-//         fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-//     IONAME(EnableHandlers)(io, true, false, false, false, false);
-//     ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
-//     ASSERT_TRUE(
-//         IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length()))
-//         << "InputAscii() " << j;
-//     ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
-//         << "EndIoStatement() for Read " << j;
-//     ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
-//         << "Input-item value after non advancing read " << j;
-//     j++;
-//   }
-
-//   // WRITE(UNIT=unit, FMT=fmt, IOSTAT=iostat) outputItem.
-//   static constexpr std::string_view outputItem{"XYZ"};
-//   // WRITE(UNIT=unit,FMT=fmt) record
-//   io = IONAME(BeginExternalFormattedOutput)(
-//       fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-//   ASSERT_TRUE(IONAME(OutputAscii)(io, outputItem.data(), outputItem.length()))
-//       << "OutputAscii()";
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for OutputAscii";
-
-//   // Verify that the output was written in the record read in non advancing
-//   // mode, after the read part, and that the end was truncated.
-
-//   // REWIND(UNIT=unit)
-//   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for Rewind";
-
-//   std::string resultRecord(20, '+');
-//   std::string expectedRecord{"ABCDEFGHXYZ         "};
-//   // READ(UNIT=unit, FMT=fmt, IOSTAT=iostat) result
-//   io = IONAME(BeginExternalFormattedInput)(
-//       fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
-//   IONAME(EnableHandlers)(io, true, false, false, false, false);
-//   ASSERT_TRUE(
-//       IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
-//       << "InputAscii() ";
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for Read ";
-//   ASSERT_EQ(resultRecord, expectedRecord)
-//       << "Record after non advancing read followed by write";
-//   // CLOSE(UNIT=unit)
-//   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
-//   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
-//       << "EndIoStatement() for Close";
-// }
+TEST(ExternalIOTests, TestWriteAfterNonAvancingInput) {
+  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+  //   FORM='FORMATTED',STATUS='SCRATCH')
+  auto *io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  ASSERT_TRUE(IONAME(SetAccess)(io, "SEQUENTIAL", 10))
+      << "SetAccess(SEQUENTIAL)";
+  ASSERT_TRUE(IONAME(SetAction)(io, "READWRITE", 9)) << "SetAction(READWRITE)";
+  ASSERT_TRUE(IONAME(SetForm)(io, "FORMATTED", 9)) << "SetForm(FORMATTED)";
+  ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
+
+  int unit{-1};
+  ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for OpenNewUnit";
+
+  // Write the file to be used for the input test.
+  static constexpr std::string_view records[] = {"ABCDEFGHIJKLMNOPQRST"};
+  static constexpr std::string_view fmt{"(A)"};
+  for (const auto &record : records) {
+    // WRITE(UNIT=unit,FMT=fmt) record
+    io = IONAME(BeginExternalFormattedOutput)(
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+    ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
+        << "OutputAscii()";
+    ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+        << "EndIoStatement() for OutputAscii";
+  }
+
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for Rewind";
+
+  struct TestItems {
+    std::string item;
+    int expectedIoStat;
+    std::string expectedItemValue;
+  };
+  // Actual non advancing input IO test
+  TestItems inputItems[]{
+      {std::string(4, '+'), IostatOk, "ABCD"},
+      {std::string(4, '+'), IostatOk, "EFGH"},
+  };
+
+  int j{0};
+  for (auto &inputItem : inputItems) {
+    // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
+    io = IONAME(BeginExternalFormattedInput)(
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+    IONAME(EnableHandlers)(io, true, false, false, false, false);
+    ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
+    ASSERT_TRUE(
+        IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length()))
+        << "InputAscii() " << j;
+    ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
+        << "EndIoStatement() for Read " << j;
+    ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
+        << "Input-item value after non advancing read " << j;
+    j++;
+  }
+
+  // WRITE(UNIT=unit, FMT=fmt, IOSTAT=iostat) outputItem.
+  static constexpr std::string_view outputItem{"XYZ"};
+  // WRITE(UNIT=unit,FMT=fmt) record
+  io = IONAME(BeginExternalFormattedOutput)(
+      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+  ASSERT_TRUE(IONAME(OutputAscii)(io, outputItem.data(), outputItem.length()))
+      << "OutputAscii()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for OutputAscii";
+
+  // Verify that the output was written in the record read in non advancing
+  // mode, after the read part, and that the end was truncated.
+
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for Rewind";
+
+  std::string resultRecord(20, '+');
+  std::string expectedRecord{"ABCDEFGHXYZ         "};
+  // READ(UNIT=unit, FMT=fmt, IOSTAT=iostat) result
+  io = IONAME(BeginExternalFormattedInput)(
+      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+  IONAME(EnableHandlers)(io, true, false, false, false, false);
+  ASSERT_TRUE(
+      IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
+      << "InputAscii() ";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for Read ";
+  ASSERT_EQ(resultRecord, expectedRecord)
+      << "Record after non advancing read followed by write";
+  // CLOSE(UNIT=unit)
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for Close";
+}
 
 TEST(ExternalIOTests, TestWriteAfterEndfile) {
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
diff --git a/flang/unittests/Runtime/Format.cpp b/flang/unittests/Runtime/Format.cpp
index cdcdc19aff54a..01803c628de26 100644
--- a/flang/unittests/Runtime/Format.cpp
+++ b/flang/unittests/Runtime/Format.cpp
@@ -145,18 +145,18 @@ TEST(FormatTests, FormatStringTraversal) {
 
 struct InvalidFormatFailure : CrashHandlerFixture {};
 
-// TEST(InvalidFormatFailure, ParenMismatch) {
-//   static constexpr const char *format{"("};
-//   static constexpr int repeat{1};
-
-//   TestFormatContext context;
-//   FormatControl<decltype(context)> control{
-//       context, format, std::strlen(format)};
-
-//   ASSERT_DEATH(
-//       context.Report(/*edit=*/control.GetNextDataEdit(context, repeat)),
-//       R"(FORMAT missing at least one '\)')");
-// }
+TEST(InvalidFormatFailure, ParenMismatch) {
+  static constexpr const char *format{"("};
+  static constexpr int repeat{1};
+
+  TestFormatContext context;
+  FormatControl<decltype(context)> control{
+      context, format, std::strlen(format)};
+
+  ASSERT_DEATH(
+      context.Report(/*edit=*/control.GetNextDataEdit(context, repeat)),
+      R"(FORMAT missing at least one '\)')");
+}
 
 TEST(InvalidFormatFailure, MissingPrecision) {
   static constexpr const char *format{"(F9.)"};
diff --git a/flang/unittests/Runtime/ListInputTest.cpp b/flang/unittests/Runtime/ListInputTest.cpp
index c53a10a0af640..a4eba5283add6 100644
--- a/flang/unittests/Runtime/ListInputTest.cpp
+++ b/flang/unittests/Runtime/ListInputTest.cpp
@@ -155,35 +155,35 @@ using ParamTy = std::tuple<std::string, std::vector<int>>;
 
 struct SimpleListInputTest : testing::TestWithParam<ParamTy> {};
 
-// TEST_P(SimpleListInputTest, TestListInput) {
-//   auto [formatBuffer, expectedOutput] = GetParam();
-//   constexpr int numBuffers{1};
-
-//   StaticDescriptor<1> staticDescriptor;
-//   Descriptor &whole{staticDescriptor.descriptor()};
-//   SubscriptValue extent[]{numBuffers};
-//   whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
-//       formatBuffer.data(), 1, extent, CFI_attribute_pointer);
-//   whole.Check();
-//   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
-
-//   const auto listInputLength{expectedOutput.size()};
-//   std::vector<std::int64_t> actualOutput(listInputLength);
-//   for (std::size_t j = 0; j < listInputLength; ++j) {
-//     IONAME(InputInteger)(cookie, actualOutput[j]);
-//   }
-
-//   const auto status{IONAME(EndIoStatement)(cookie)};
-//   ASSERT_EQ(status, 0) << "list-directed input failed, status "
-//                        << static_cast<int>(status) << '\n';
-
-//   // Verify the calls to _InputInteger_ resulted in _expectedOutput_
-//   for (std::size_t j = 0; j < listInputLength; ++j) {
-//     ASSERT_EQ(actualOutput[j], expectedOutput[j])
-//         << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
-//         << actualOutput[j] << '\n';
-//   }
-// }
+TEST_P(SimpleListInputTest, TestListInput) {
+  auto [formatBuffer, expectedOutput] = GetParam();
+  constexpr int numBuffers{1};
+
+  StaticDescriptor<1> staticDescriptor;
+  Descriptor &whole{staticDescriptor.descriptor()};
+  SubscriptValue extent[]{numBuffers};
+  whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
+      formatBuffer.data(), 1, extent, CFI_attribute_pointer);
+  whole.Check();
+  auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
+
+  const auto listInputLength{expectedOutput.size()};
+  std::vector<std::int64_t> actualOutput(listInputLength);
+  for (std::size_t j = 0; j < listInputLength; ++j) {
+    IONAME(InputInteger)(cookie, actualOutput[j]);
+  }
+
+  const auto status{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(status, 0) << "list-directed input failed, status "
+                       << static_cast<int>(status) << '\n';
+
+  // Verify the calls to _InputInteger_ resulted in _expectedOutput_
+  for (std::size_t j = 0; j < listInputLength; ++j) {
+    ASSERT_EQ(actualOutput[j], expectedOutput[j])
+        << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
+        << actualOutput[j] << '\n';
+  }
+}
 
 INSTANTIATE_TEST_SUITE_P(SimpleListInputTestInstantiation, SimpleListInputTest,
     testing::Values(std::make_tuple("", std::vector<int>{}),
diff --git a/flang/unittests/Runtime/MiscIntrinsic.cpp b/flang/unittests/Runtime/MiscIntrinsic.cpp
index 6dff30a5c1efc..7e19ed250bdc0 100644
--- a/flang/unittests/Runtime/MiscIntrinsic.cpp
+++ b/flang/unittests/Runtime/MiscIntrinsic.cpp
@@ -68,21 +68,21 @@ TEST(MiscIntrinsic, TransferSize) {
   EXPECT_EQ(result.OffsetElement<float>()[1], 2.2F);
   result.Destroy();
 }
-// TEST(MiscIntrinsic, TransferSizeScalarMold) {
-//   StaticDescriptor<2, true, 2> staticDesc[2];
-//   auto &result{staticDesc[0].descriptor()};
-//   std::complex<float> sourecStorage{1.1F, -2.2F};
-//   auto source{Descriptor::Create(TypeCategory::Complex, 4,
-//       reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
-//       CFI_attribute_pointer)};
-//   auto &mold{staticDesc[1].descriptor()};
-//   mold.Establish(TypeCategory::Real, 4, nullptr, 0, nullptr);
-//   RTNAME(TransferSize)(result, *source, mold, __FILE__, __LINE__, 2);
-//   EXPECT_EQ(result.rank(), 1);
-//   EXPECT_EQ(result.GetDimension(0).LowerBound(), 1);
-//   EXPECT_EQ(result.GetDimension(0).Extent(), 2);
-//   EXPECT_EQ(result.type().raw(), (TypeCode{TypeCategory::Real, 4}.raw()));
-//   EXPECT_EQ(result.OffsetElement<float>()[0], 1.1F);
-//   EXPECT_EQ(result.OffsetElement<float>()[1], -2.2F);
-//   result.Destroy();
-// }
+TEST(MiscIntrinsic, TransferSizeScalarMold) {
+  StaticDescriptor<2, true, 2> staticDesc[2];
+  auto &result{staticDesc[0].descriptor()};
+  std::complex<float> sourecStorage{1.1F, -2.2F};
+  auto source{Descriptor::Create(TypeCategory::Complex, 4,
+      reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
+      CFI_attribute_pointer)};
+  auto &mold{staticDesc[1].descriptor()};
+  mold.Establish(TypeCategory::Real, 4, nullptr, 0, nullptr);
+  RTNAME(TransferSize)(result, *source, mold, __FILE__, __LINE__, 2);
+  EXPECT_EQ(result.rank(), 1);
+  EXPECT_EQ(result.GetDimension(0).LowerBound(), 1);
+  EXPECT_EQ(result.GetDimension(0).Extent(), 2);
+  EXPECT_EQ(result.type().raw(), (TypeCode{TypeCategory::Real, 4}.raw()));
+  EXPECT_EQ(result.OffsetElement<float>()[0], 1.1F);
+  EXPECT_EQ(result.OffsetElement<float>()[1], -2.2F);
+  result.Destroy();
+}
diff --git a/flang/unittests/Runtime/Numeric.cpp b/flang/unittests/Runtime/Numeric.cpp
index 98ec88abf9a93..b69ff21ea79fb 100644
--- a/flang/unittests/Runtime/Numeric.cpp
+++ b/flang/unittests/Runtime/Numeric.cpp
@@ -31,15 +31,15 @@ TEST(Numeric, Floor) {
   EXPECT_EQ(RTNAME(Floor4_1)(Real<4>{0}), 0);
 }
 
-// TEST(Numeric, Exponent) {
-//   EXPECT_EQ(RTNAME(Exponent4_4)(Real<4>{0}), 0);
-//   EXPECT_EQ(RTNAME(Exponent4_8)(Real<4>{1.0}), 1);
-//   EXPECT_EQ(RTNAME(Exponent8_4)(Real<8>{4.1}), 3);
-//   EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::infinity()),
-//       std::numeric_limits<Int<8>>::max());
-//   EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::quiet_NaN()),
-//       std::numeric_limits<Int<8>>::max());
-// }
+TEST(Numeric, Exponent) {
+  EXPECT_EQ(RTNAME(Exponent4_4)(Real<4>{0}), 0);
+  EXPECT_EQ(RTNAME(Exponent4_8)(Real<4>{1.0}), 1);
+  EXPECT_EQ(RTNAME(Exponent8_4)(Real<8>{4.1}), 3);
+  EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::infinity()),
+      std::numeric_limits<Int<8>>::max());
+  EXPECT_EQ(RTNAME(Exponent8_8)(std::numeric_limits<Real<8>>::quiet_NaN()),
+      std::numeric_limits<Int<8>>::max());
+}
 
 TEST(Numeric, Fraction) {
   EXPECT_EQ(RTNAME(Fraction4)(Real<4>{0}), 0);
@@ -192,57 +192,57 @@ TEST(Numeric, SelectedIntKind) {
   EXPECT_EQ(RTNAME(SelectedIntKind)(__FILE__, __LINE__, &r5, 4), -1);
 }
 
-// TEST(Numeric, SelectedRealKind) {
-//   std::int8_t p_s = 1;
-//   std::int16_t p[11] = {-10, 1, 1, 4, 50, 1, 1, 4, 1, 1, 50};
-//   std::int32_t r[11] = {-1, 1, 1, 1, 2, 1, 20, 20, 100, 5000, 5000};
-//   std::int64_t d[11] = {2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2};
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[0], 2, &r[0], 4, &d[0], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[1], 2, &r[1], 4, &d[1], 8),
-//       -5);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[2], 2, &r[2], 4, &d[2], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[3], 2, &r[3], 4, &d[3], 8),
-//       4);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[4], 2, &r[4], 4, &d[4], 8),
-//       -1);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[5], 2, &r[5], 4, &d[5], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[6], 2, &r[6], 4, &d[6], 8),
-//       3);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[7], 2, &r[7], 4, &d[7], 8),
-//       4);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[8], 2, &r[8], 4, &d[8], 8),
-//       8);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[9], 2, &r[9], 4, &d[9], 8),
-//       -2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[10], 2, &r[10], 4, &d[10], 8),
-//       -3);
-//   EXPECT_EQ(
-//       RTNAME(SelectedRealKind)(__FILE__, __LINE__, &p_s, 1, &r[0], 4, &d[0], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, nullptr, 0, &r[0], 4, &d[0], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[0], 2, nullptr, 0, &d[0], 8),
-//       2);
-//   EXPECT_EQ(RTNAME(SelectedRealKind)(
-//                 __FILE__, __LINE__, &p[0], 2, &r[0], 4, nullptr, 0),
-//       2);
-// }
+TEST(Numeric, SelectedRealKind) {
+  std::int8_t p_s = 1;
+  std::int16_t p[11] = {-10, 1, 1, 4, 50, 1, 1, 4, 1, 1, 50};
+  std::int32_t r[11] = {-1, 1, 1, 1, 2, 1, 20, 20, 100, 5000, 5000};
+  std::int64_t d[11] = {2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[0], 2, &r[0], 4, &d[0], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[1], 2, &r[1], 4, &d[1], 8),
+      -5);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[2], 2, &r[2], 4, &d[2], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[3], 2, &r[3], 4, &d[3], 8),
+      4);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[4], 2, &r[4], 4, &d[4], 8),
+      -1);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[5], 2, &r[5], 4, &d[5], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[6], 2, &r[6], 4, &d[6], 8),
+      3);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[7], 2, &r[7], 4, &d[7], 8),
+      4);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[8], 2, &r[8], 4, &d[8], 8),
+      8);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[9], 2, &r[9], 4, &d[9], 8),
+      -2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[10], 2, &r[10], 4, &d[10], 8),
+      -3);
+  EXPECT_EQ(
+      RTNAME(SelectedRealKind)(__FILE__, __LINE__, &p_s, 1, &r[0], 4, &d[0], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, nullptr, 0, &r[0], 4, &d[0], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[0], 2, nullptr, 0, &d[0], 8),
+      2);
+  EXPECT_EQ(RTNAME(SelectedRealKind)(
+                __FILE__, __LINE__, &p[0], 2, &r[0], 4, nullptr, 0),
+      2);
+}
 
 TEST(Numeric, Spacing) {
   EXPECT_EQ(RTNAME(Spacing8)(Real<8>{0}), std::numeric_limits<Real<8>>::min());
diff --git a/flang/unittests/Runtime/NumericalFormatTest.cpp b/flang/unittests/Runtime/NumericalFormatTest.cpp
index d480e41268b6b..2a9f8f8d1dc4f 100644
--- a/flang/unittests/Runtime/NumericalFormatTest.cpp
+++ b/flang/unittests/Runtime/NumericalFormatTest.cpp
@@ -336,21 +336,21 @@ TEST(IOApiTests, FormatOnes) {
   }
 }
 
-// TEST(IOApiTests, FormatNegativeOnes) {
-//   static constexpr std::tuple<const char *, const char *> negOnes[]{
-//       {"(E32.17,';')", "        -0.10000000000000000E+01;"},
-//       {"(F32.17,';')", "            -1.00000000000000000;"},
-//       {"(G32.17,';')", "         -1.0000000000000000    ;"},
-//       {"(EX32.17,';')", "       -0X8.00000000000000000P-3;"},
-//       {"(G0,';')", "-1.;"},
-//   };
-//   for (auto const &[format, expect] : negOnes) {
-//     std::string got;
-//     ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
-//         << "Failed to format " << format << ", expected '" << expect
-//         << "', got '" << got << "'";
-//   }
-// }
+TEST(IOApiTests, FormatNegativeOnes) {
+  static constexpr std::tuple<const char *, const char *> negOnes[]{
+      {"(E32.17,';')", "        -0.10000000000000000E+01;"},
+      {"(F32.17,';')", "            -1.00000000000000000;"},
+      {"(G32.17,';')", "         -1.0000000000000000    ;"},
+      {"(EX32.17,';')", "       -0X8.00000000000000000P-3;"},
+      {"(G0,';')", "-1.;"},
+  };
+  for (auto const &[format, expect] : negOnes) {
+    std::string got;
+    ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
+        << "Failed to format " << format << ", expected '" << expect
+        << "', got '" << got << "'";
+  }
+}
 
 // Each test case contains a raw uint64, a format string for a real value, and
 // the expected resulting string from formatting the raw uint64. The double
diff --git a/flang/unittests/Runtime/Pointer.cpp b/flang/unittests/Runtime/Pointer.cpp
index 30edf82fbcf13..4ce13ebc50a56 100644
--- a/flang/unittests/Runtime/Pointer.cpp
+++ b/flang/unittests/Runtime/Pointer.cpp
@@ -64,25 +64,25 @@ TEST(Pointer, DeallocatePolymorphic) {
   (*p, nullptr, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
 }
 
-// TEST(Pointer, AllocateFromScalarSource) {
-//   // REAL(4), POINTER :: p(:)
-//   auto p{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, 4,
-//       nullptr, 1, nullptr, CFI_attribute_pointer)};
-//   // ALLOCATE(p(2:11), SOURCE=3.4)
-//   float sourecStorage{3.4F};
-//   auto s{Descriptor::Create(Fortran::common::TypeCategory::Real, 4,
-//       reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
-//       CFI_attribute_pointer)};
-//   RTNAME(PointerSetBounds)(*p, 0, 2, 11);
-//   RTNAME(PointerAllocateSource)
-//   (*p, *s, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
-//   EXPECT_TRUE(RTNAME(PointerIsAssociated)(*p));
-//   EXPECT_EQ(p->Elements(), 10u);
-//   EXPECT_EQ(p->GetDimension(0).LowerBound(), 2);
-//   EXPECT_EQ(p->GetDimension(0).UpperBound(), 11);
-//   EXPECT_EQ(*p->OffsetElement<float>(), 3.4F);
-//   p->Destroy();
-// }
+TEST(Pointer, AllocateFromScalarSource) {
+  // REAL(4), POINTER :: p(:)
+  auto p{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, 4,
+      nullptr, 1, nullptr, CFI_attribute_pointer)};
+  // ALLOCATE(p(2:11), SOURCE=3.4)
+  float sourecStorage{3.4F};
+  auto s{Descriptor::Create(Fortran::common::TypeCategory::Real, 4,
+      reinterpret_cast<void *>(&sourecStorage), 0, nullptr,
+      CFI_attribute_pointer)};
+  RTNAME(PointerSetBounds)(*p, 0, 2, 11);
+  RTNAME(PointerAllocateSource)
+  (*p, *s, /*hasStat=*/false, /*errMsg=*/nullptr, __FILE__, __LINE__);
+  EXPECT_TRUE(RTNAME(PointerIsAssociated)(*p));
+  EXPECT_EQ(p->Elements(), 10u);
+  EXPECT_EQ(p->GetDimension(0).LowerBound(), 2);
+  EXPECT_EQ(p->GetDimension(0).UpperBound(), 11);
+  EXPECT_EQ(*p->OffsetElement<float>(), 3.4F);
+  p->Destroy();
+}
 
 TEST(Pointer, AllocateSourceZeroSize) {
   using Fortran::common::TypeCategory;
diff --git a/flang/unittests/Runtime/RuntimeCrashTest.cpp b/flang/unittests/Runtime/RuntimeCrashTest.cpp
index 0753f76f23cc3..a649051fdca0c 100644
--- a/flang/unittests/Runtime/RuntimeCrashTest.cpp
+++ b/flang/unittests/Runtime/RuntimeCrashTest.cpp
@@ -53,15 +53,15 @@ TEST(TestTerminator, CheckFailedTest) {
 //------------------------------------------------------------------------------
 struct TestIOCrash : CrashHandlerFixture {};
 
-// TEST(TestIOCrash, InvalidFormatCharacterTest) {
-//   static constexpr int bufferSize{1};
-//   static char buffer[bufferSize];
-//   static const char *format{"(C1)"};
-//   auto *cookie{IONAME(BeginInternalFormattedOutput)(
-//       buffer, bufferSize, format, std::strlen(format))};
-//   ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xfeedface),
-//       "Unknown 'C' edit descriptor in FORMAT");
-// }
+TEST(TestIOCrash, InvalidFormatCharacterTest) {
+  static constexpr int bufferSize{1};
+  static char buffer[bufferSize];
+  static const char *format{"(C1)"};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, bufferSize, format, std::strlen(format))};
+  ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xfeedface),
+      "Unknown 'C' edit descriptor in FORMAT");
+}
 
 //------------------------------------------------------------------------------
 /// Test buffer overwrites with Output* functions
diff --git a/flang/unittests/Runtime/Stop.cpp b/flang/unittests/Runtime/Stop.cpp
index 24c78251ea697..b13602eaee5ea 100644
--- a/flang/unittests/Runtime/Stop.cpp
+++ b/flang/unittests/Runtime/Stop.cpp
@@ -32,24 +32,24 @@ TEST(TestProgramEnd, StopTestNoStopMessage) {
       RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-// TEST(TestProgramEnd, StopMessageTest) {
-//   static const char *message{"bye bye"};
-//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-//                   /*isErrorStop=*/false, /*quiet=*/false),
-//       testing::ExitedWithCode(EXIT_SUCCESS), "Fortran STOP: bye bye");
-
-//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-//                   /*isErrorStop=*/false, /*quiet=*/true),
-//       testing::ExitedWithCode(EXIT_SUCCESS), "");
-
-//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-//                   /*isErrorStop=*/true, /*quiet=*/false),
-//       testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
-
-//   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
-//                   /*isErrorStop=*/true, /*quiet=*/true),
-//       testing::ExitedWithCode(EXIT_FAILURE), "");
-// }
+TEST(TestProgramEnd, StopMessageTest) {
+  static const char *message{"bye bye"};
+  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+                  /*isErrorStop=*/false, /*quiet=*/false),
+      testing::ExitedWithCode(EXIT_SUCCESS), "Fortran STOP: bye bye");
+
+  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+                  /*isErrorStop=*/false, /*quiet=*/true),
+      testing::ExitedWithCode(EXIT_SUCCESS), "");
+
+  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+                  /*isErrorStop=*/true, /*quiet=*/false),
+      testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
+
+  EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
+                  /*isErrorStop=*/true, /*quiet=*/true),
+      testing::ExitedWithCode(EXIT_FAILURE), "");
+}
 
 TEST(TestProgramEnd, NoStopMessageTest) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
diff --git a/flang/unittests/Runtime/TemporaryStack.cpp b/flang/unittests/Runtime/TemporaryStack.cpp
index 8b9aac99309ad..0a9344969ca6b 100644
--- a/flang/unittests/Runtime/TemporaryStack.cpp
+++ b/flang/unittests/Runtime/TemporaryStack.cpp
@@ -87,86 +87,86 @@ static unsigned max(unsigned x, unsigned y) {
   return y;
 }
 
-// TEST(TemporaryStack, ValueStackMultiSize) {
-//   constexpr unsigned numToTest = 42;
-//   const TypeCode code{CFI_type_int32_t};
-//   constexpr size_t elementBytes = 4;
-//   SubscriptValue extent[CFI_MAX_RANK];
-
-//   std::vector<OwningPtr<Descriptor>> inputDescriptors;
-//   inputDescriptors.reserve(numToTest);
-
-//   void *storage = RTNAME(CreateValueStack)(__FILE__, __LINE__);
-//   ASSERT_NE(storage, nullptr);
-
-//   // create descriptors with and without adendums
-//   auto getAdendum = [](unsigned i) { return i % 2; };
-//   // create descriptors with varying ranks
-//   auto getRank = [](unsigned i) { return max(i % 8, 1); };
-
-//   // push descriptors of varying sizes and contents
-//   for (unsigned i = 0; i < numToTest; ++i) {
-//     const bool adendum = getAdendum(i);
-//     const size_t rank = getRank(i);
-//     for (unsigned dim = 0; dim < rank; ++dim) {
-//       extent[dim] = ((i + dim) % 8) + 1;
-//     }
-
-//     const OwningPtr<Descriptor> &desc =
-//         inputDescriptors.emplace_back(Descriptor::Create(code, elementBytes,
-//             nullptr, rank, extent, CFI_attribute_allocatable, adendum));
-
-//     // Descriptor::Establish doesn't initialise the extents if baseaddr is null
-//     for (unsigned dim = 0; dim < rank; ++dim) {
-//       Fortran::ISO::CFI_dim_t &boxDims = desc->raw().dim[dim];
-//       boxDims.lower_bound = 1;
-//       boxDims.extent = extent[dim];
-//       boxDims.sm = elementBytes;
-//     }
-//     desc->Allocate();
-
-//     // fill the array with some data to test
-//     for (uint32_t i = 0; i < desc->Elements(); ++i) {
-//       uint32_t *data = static_cast<uint32_t *>(desc->raw().base_addr);
-//       ASSERT_NE(data, nullptr);
-//       data[i] = i;
-//     }
-
-//     RTNAME(PushValue)(storage, *desc.get());
-//   }
-
-//   const TypeCode boolCode{CFI_type_Bool};
-//   // peek and test each descriptor
-//   for (unsigned i = 0; i < numToTest; ++i) {
-//     const OwningPtr<Descriptor> &input = inputDescriptors[i];
-//     const bool adendum = getAdendum(i);
-//     const size_t rank = getRank(i);
-
-//     // buffer to return the descriptor into
-//     OwningPtr<Descriptor> out = Descriptor::Create(
-//         boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
-
-//     (void)input;
-//     RTNAME(ValueAt)(storage, i, *out.get());
-//     descriptorAlmostEqual(*input, *out);
-//   }
-
-//   // pop and test each descriptor
-//   for (unsigned i = numToTest; i > 0; --i) {
-//     const OwningPtr<Descriptor> &input = inputDescriptors[i - 1];
-//     const bool adendum = getAdendum(i - 1);
-//     const size_t rank = getRank(i - 1);
-
-//     // buffer to return the descriptor into
-//     OwningPtr<Descriptor> out = Descriptor::Create(
-//         boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
-
-//     RTNAME(PopValue)(storage, *out.get());
-//     descriptorAlmostEqual(*input, *out);
-//   }
-
-//   RTNAME(DestroyValueStack)(storage);
-// }
+TEST(TemporaryStack, ValueStackMultiSize) {
+  constexpr unsigned numToTest = 42;
+  const TypeCode code{CFI_type_int32_t};
+  constexpr size_t elementBytes = 4;
+  SubscriptValue extent[CFI_MAX_RANK];
+
+  std::vector<OwningPtr<Descriptor>> inputDescriptors;
+  inputDescriptors.reserve(numToTest);
+
+  void *storage = RTNAME(CreateValueStack)(__FILE__, __LINE__);
+  ASSERT_NE(storage, nullptr);
+
+  // create descriptors with and without adendums
+  auto getAdendum = [](unsigned i) { return i % 2; };
+  // create descriptors with varying ranks
+  auto getRank = [](unsigned i) { return max(i % 8, 1); };
+
+  // push descriptors of varying sizes and contents
+  for (unsigned i = 0; i < numToTest; ++i) {
+    const bool adendum = getAdendum(i);
+    const size_t rank = getRank(i);
+    for (unsigned dim = 0; dim < rank; ++dim) {
+      extent[dim] = ((i + dim) % 8) + 1;
+    }
+
+    const OwningPtr<Descriptor> &desc =
+        inputDescriptors.emplace_back(Descriptor::Create(code, elementBytes,
+            nullptr, rank, extent, CFI_attribute_allocatable, adendum));
+
+    // Descriptor::Establish doesn't initialise the extents if baseaddr is null
+    for (unsigned dim = 0; dim < rank; ++dim) {
+      Fortran::ISO::CFI_dim_t &boxDims = desc->raw().dim[dim];
+      boxDims.lower_bound = 1;
+      boxDims.extent = extent[dim];
+      boxDims.sm = elementBytes;
+    }
+    desc->Allocate();
+
+    // fill the array with some data to test
+    for (uint32_t i = 0; i < desc->Elements(); ++i) {
+      uint32_t *data = static_cast<uint32_t *>(desc->raw().base_addr);
+      ASSERT_NE(data, nullptr);
+      data[i] = i;
+    }
+
+    RTNAME(PushValue)(storage, *desc.get());
+  }
+
+  const TypeCode boolCode{CFI_type_Bool};
+  // peek and test each descriptor
+  for (unsigned i = 0; i < numToTest; ++i) {
+    const OwningPtr<Descriptor> &input = inputDescriptors[i];
+    const bool adendum = getAdendum(i);
+    const size_t rank = getRank(i);
+
+    // buffer to return the descriptor into
+    OwningPtr<Descriptor> out = Descriptor::Create(
+        boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
+
+    (void)input;
+    RTNAME(ValueAt)(storage, i, *out.get());
+    descriptorAlmostEqual(*input, *out);
+  }
+
+  // pop and test each descriptor
+  for (unsigned i = numToTest; i > 0; --i) {
+    const OwningPtr<Descriptor> &input = inputDescriptors[i - 1];
+    const bool adendum = getAdendum(i - 1);
+    const size_t rank = getRank(i - 1);
+
+    // buffer to return the descriptor into
+    OwningPtr<Descriptor> out = Descriptor::Create(
+        boolCode, 1, nullptr, rank, extent, CFI_attribute_other, adendum);
+
+    RTNAME(PopValue)(storage, *out.get());
+    descriptorAlmostEqual(*input, *out);
+  }
+
+  RTNAME(DestroyValueStack)(storage);
+}
 
 TEST(TemporaryStack, DescriptorStackBasic) {
   const TypeCode code{CFI_type_Bool};

>From e278a9d5100149068754a20abb931b79bb78e923 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 19 May 2024 22:40:05 +0300
Subject: [PATCH 11/11] Comment out all flang tests

---
 flang/unittests/CMakeLists.txt | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/flang/unittests/CMakeLists.txt b/flang/unittests/CMakeLists.txt
index 72d37ebeb853c..f04b91497b172 100644
--- a/flang/unittests/CMakeLists.txt
+++ b/flang/unittests/CMakeLists.txt
@@ -70,9 +70,9 @@ function(add_flang_nongtest_unittest test_name)
   add_flang_unittest_offload_properties(${test_name}${suffix})
 endfunction()
 
-add_subdirectory(Optimizer)
-add_subdirectory(Common)
-add_subdirectory(Decimal)
-add_subdirectory(Evaluate)
-add_subdirectory(Runtime)
-add_subdirectory(Frontend)
+# add_subdirectory(Optimizer)
+# add_subdirectory(Common)
+# add_subdirectory(Decimal)
+# add_subdirectory(Evaluate)
+# add_subdirectory(Runtime)
+# add_subdirectory(Frontend)



More information about the flang-commits mailing list