assert r.results.any { TestMethodResult m ->
                m.name == 'methodFoo' && m.resultType == TestResult.ResultType.SUCCESS
            }
            assert r.results.any { TestMethodResult m ->
                m.name == 'methodFoo' && m.resultType == TestResult.ResultType.FAILURE
            }
        }
        0 * action._
    }

		for pt, applied := range pmap {
			if applied {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(1)
			} else {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(0)
			}
		}
	}
	envoyFilterStatusMap = make(map[string]map[string]bool)

        String displayName = decoder.readString();
        TestResult.ResultType resultType = TestResult.ResultType.values()[decoder.readSmallInt()];
        long duration = decoder.readSmallLong();
        long endTime = decoder.readLong();
        TestMethodResult methodResult = new TestMethodResult(id, name, displayName, resultType, duration, endTime);
        int failures = decoder.readSmallInt();

  // All the rest: states, device.
  for (int i = 2; i < 5; ++i) {
    auto result_type =
        mlir::dyn_cast<RankedTensorType>(func_op.getResultTypes()[i]);
    outputs.push_back(CreatTfF32ConstOp(builder, result_type.getShape(), 0.0f,
                                        func_op.getLoc()));
    output_types.push_back(result_type);
  }

  // Update function signatures.

        eventLogger.afterTest(methodDescriptor, result)

        then:
        textOutputFactory.toString().count("PASSED") == 1

        when:
        textOutputFactory.clear()
        result.resultType = TestResult.ResultType.FAILURE
        eventLogger.afterTest(methodDescriptor, result)

        then:
        textOutputFactory.toString().count("PASSED") == 0
    }

    def "logs event if granularity matches"() {

  if (x_type.getShape() != y_type.getShape()) return failure();

  auto result_type = squared_diff_op.getType();
  if (!result_type) return failure();

  auto sub_op =
      rewriter.create<TF::SubOp>(squared_diff_op.getLoc(), result_type, x, y);
  auto mul_op =
      rewriter.create<TF::MulOp>(squared_diff_op.getLoc(), result_type,
                                 sub_op.getResult(), sub_op.getResult());

            }
            assert testInternal != null : String.format("Unexpected end event for %s", description);
            resultType = assumptionFailed.remove(description) ? TestResult.ResultType.SKIPPED : null;
        }
        resultProcessor.completed(testInternal.getId(), new TestCompleteEvent(endTime, resultType));
    }

    private static TestDescriptorInternal descriptor(Object id, Description description) {

            processor.completed(testId, Stub(TestCompleteEvent) {
                getResultType() >> TestResult.ResultType.FAILURE
            })
            processor.started(suiteDescriptor, startEvent)
            processor.completed(testId, Stub(TestCompleteEvent) {
                getResultType() >> TestResult.ResultType.SUCCESS
            })
        }
    }

    def expectFirstTestSuiteContainsTestButSecondIsEmpty() {

    const auto result_type = mlir::cast<TensorType>(op.getResult(0).getType());
    const SmallVector<int64_t> new_result_shape =
        Permute<int64_t>(result_type.getShape(), kNchwToNhwcPermutation);

    const TensorType new_result_type =
        result_type.cloneWith(new_result_shape, result_type.getElementType());

        def event1 = new TestCompleteEvent(123L, TestResult.ResultType.SUCCESS)
        def event2 = new TestCompleteEvent(123L, null)

        when:
        def result1 = serialize(event1)
        def result2 = serialize(event2)

        then:
        result1 instanceof TestCompleteEvent
        result1.endTime == 123L
        result1.resultType == TestResult.ResultType.SUCCESS
        result2 instanceof TestCompleteEvent