[Backend Tester] Clean up report output

backends/qualcomm/tests/tester.py

@@ -52,7 +52,9 @@ def __init__(
             default_partitioner_cls=QnnPartitioner,
         )
 
-    def run(self, artifact: ExportedProgram, inputs=None) -> None:
+    def run(
+        self, artifact: ExportedProgram, inputs=None, generate_etrecord: bool = False
+    ) -> None:
         ep = QnnPassManager().transform_for_export_pipeline(artifact)
         transform_passes = QnnPassManager().get_to_edge_transform_passes(ep)
 
@@ -61,6 +63,7 @@ def run(self, artifact: ExportedProgram, inputs=None) -> None:
             transform_passes=transform_passes,
             partitioner=self.partitioners,
             compile_config=self.edge_compile_conf,
+            generate_etrecord=generate_etrecord,
         )
 
 

backends/test/harness/stages/to_edge_transform_and_lower.py

@@ -7,28 +7,38 @@
     to_edge_transform_and_lower,
 )
 from executorch.exir.backend.partitioner import Partitioner
+
 from torch.export import ExportedProgram
 
 
 class ToEdgeTransformAndLower(Stage):
     def __init__(
         self,
-        default_partitioner_cls: Type,
+        default_partitioner_cls: Type | None = None,
         partitioners: Optional[List[Partitioner]] = None,
         edge_compile_config: Optional[EdgeCompileConfig] = None,
     ):
-        self.partitioners = partitioners or [default_partitioner_cls()]
-        self.edge_compile_conf = edge_compile_config or EdgeCompileConfig()
+        self.partitioners = (
+            partitioners or [default_partitioner_cls()]
+            if default_partitioner_cls is not None
+            else []
+        )
+        self.edge_compile_conf = edge_compile_config or EdgeCompileConfig(
+            _check_ir_validity=False
+        )
         self.edge_dialect_program = None
 
     def stage_type(self) -> StageType:
         return StageType.TO_EDGE_TRANSFORM_AND_LOWER
 
-    def run(self, artifact: ExportedProgram, inputs=None) -> None:
+    def run(
+        self, artifact: ExportedProgram, inputs=None, generate_etrecord: bool = False
+    ) -> None:
         self.edge_dialect_program = to_edge_transform_and_lower(
             artifact,
             compile_config=self.edge_compile_conf,
             partitioner=self.partitioners,
+            generate_etrecord=generate_etrecord,
         )
 
     @property

backends/test/harness/tester.py

@@ -34,12 +34,12 @@ def __init__(
         self,
         module: torch.nn.Module,
         example_inputs: Tuple[torch.Tensor],
-        stage_classes: Dict[StageType, Callable],
+        stage_classes: Dict[StageType, Callable] | None = None,
         dynamic_shapes: Optional[Tuple[Any]] = None,
     ):
         module.eval()
 
-        self.stage_classes = stage_classes
+        self.stage_classes = stage_classes or Tester.default_stage_classes()
         self.original_module = module
         self.example_inputs = example_inputs
         self.dynamic_shapes = dynamic_shapes
@@ -183,10 +183,10 @@ def _post(self, stage):
         assert stage_type in self.stages
         self.stages[stage_type] = stage
 
-    def _run_stage(self, stage_instance, inputs=None):
+    def _run_stage(self, stage_instance, inputs=None, *args, **kwargs):
         assert isinstance(stage_instance, Stage)
         prev_stage_artifact = self._pre(stage_instance)
-        stage_instance.run(prev_stage_artifact, inputs=inputs)
+        stage_instance.run(prev_stage_artifact, inputs=inputs, *args, **kwargs)  # noqa
         self._post(stage_instance)
         return self
 
@@ -213,11 +213,14 @@ def to_edge(self, to_edge_stage: Optional[ToEdge] = None):
         return res
 
     def to_edge_transform_and_lower(
-        self, to_edge_and_transform_stage: Optional[ToEdgeTransformAndLower] = None
+        self,
+        to_edge_and_transform_stage: Optional[ToEdgeTransformAndLower] = None,
+        generate_etrecord: bool = False,
     ):
         return self._run_stage(
             to_edge_and_transform_stage
-            or self._get_default_stage(StageType.TO_EDGE_TRANSFORM_AND_LOWER)
+            or self._get_default_stage(StageType.TO_EDGE_TRANSFORM_AND_LOWER),
+            generate_etrecord=generate_etrecord,
         )
 
     def run_passes(self, run_passes_stage: Optional[RunPasses] = None):

backends/test/suite/flow.py

@@ -1,6 +1,6 @@
 import logging
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Callable
 
 from executorch.backends.test.harness import Tester
@@ -26,16 +26,25 @@ class TestFlow:
     tester_factory: Callable[..., Tester]
     """ A factory function that returns a Tester instance for this lowering flow. """
 
-    quantize: bool = field(default=False)
+    quantize: bool = False
     """ Whether to tester should run the quantize stage on the model. """
 
     quantize_stage_factory: Callable[..., Quantize] | None = None
     """ A factory function which instantiates a Quantize stage. Can be None to use the tester's default. """
 
+    is_delegated: bool = True
+    """ Indicates whether the flow is expected to generate CALL_DELEGATE nodes. """
+
 
 def all_flows() -> dict[str, TestFlow]:
     flows = []
 
+    from executorch.backends.test.suite.flows.portable import PORTABLE_TEST_FLOW
+
+    flows += [
+        PORTABLE_TEST_FLOW,
+    ]
+
     try:
         from executorch.backends.test.suite.flows.xnnpack import (
             XNNPACK_STATIC_INT8_PER_CHANNEL_TEST_FLOW,

backends/test/suite/flows/portable.py

@@ -0,0 +1,19 @@
+import logging
+
+from executorch.backends.test.harness import Tester
+from executorch.backends.test.suite.flow import TestFlow
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def _create_portable_flow() -> TestFlow:
+    return TestFlow(
+        "portable",
+        backend="portable",
+        tester_factory=Tester,
+        is_delegated=False,
+    )
+
+
+PORTABLE_TEST_FLOW = _create_portable_flow()

backends/test/suite/operators/test_amax.py

@@ -207,39 +207,39 @@ def test_amax_edge_cases(self, flow: TestFlow) -> None:
             AmaxModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AmaxModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AmaxModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([[1.0, float("nan"), 3.0], [4.0, 5.0, float("nan")]])
         self._test_op(
             AmaxModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AmaxModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AmaxModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
     def test_amax_scalar(self, flow: TestFlow) -> None:

backends/test/suite/operators/test_amin.py

@@ -209,39 +209,39 @@ def test_amin_edge_cases(self, flow: TestFlow) -> None:
             AminModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AminModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AminModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([[1.0, float("nan"), 3.0], [4.0, 5.0, float("nan")]])
         self._test_op(
             AminModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AminModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             AminModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
     def test_amin_scalar(self, flow: TestFlow) -> None:

backends/test/suite/operators/test_argmax.py

@@ -149,39 +149,39 @@ def test_argmax_edge_cases(self, flow: TestFlow) -> None:
             ArgmaxModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgmaxModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgmaxModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([[1.0, float("nan"), 3.0], [4.0, 5.0, float("nan")]])
         self._test_op(
             ArgmaxModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgmaxModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgmaxModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([5.0])

backends/test/suite/operators/test_argmin.py

@@ -149,39 +149,39 @@ def test_argmin_edge_cases(self, flow: TestFlow) -> None:
             ArgminModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgminModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgminModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([[1.0, float("nan"), 3.0], [4.0, 5.0, float("nan")]])
         self._test_op(
             ArgminModel(),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgminModel(dim=0),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
         self._test_op(
             ArgminModel(dim=1),
             (x,),
             flow,
-            use_random_test_inputs=False,
+            generate_random_test_inputs=False,
         )
 
         x = torch.tensor([5.0])

backends/test/suite/operators/test_floor.py

@@ -18,8 +18,8 @@
 
 
 class FloorModel(torch.nn.Module):
-    def __init__(self):
-        super().__init__()
+    def forward(self, x):
+        return torch.floor(x)
 
 
 @operator_test