boolean isMutationAllowed();

    /**
     * Throws exception when mutation is not allowed.
     *
     * @param methodName the method name the assertion is testing
     * @param target the target object been asserted on
     */
    void assertMutationAllowed(String methodName, Object target);

    <T> void assertMutationAllowed(String methodName, T target, Class<T> targetType);

These stubs form an internally consistent data-set that is not expected to change. They are
used to test the individual components in the lifecycle with data that has expected characteristics
and can be asserted as desired.

You can change/extend these stubs, and tests should not be breaking too much, since most tests
assert using expected values from the stubs. Normally, when you try to use data from the stubs that

  const FunctionDef *f1_rewritten = fld.Find("f1_rearrange_0");
  CHECK_NE(f1_rewritten, nullptr);
  ASSERT_EQ(f1_rewritten->signature().input_arg_size(), 2);
  EXPECT_EQ(f1_rewritten->signature().input_arg(0).type(), DT_BOOL);
  EXPECT_EQ(f1_rewritten->signature().input_arg(1).type(), DT_RESOURCE);
  ASSERT_EQ(f1_rewritten->signature().output_arg_size(), 1);
  EXPECT_EQ(f1_rewritten->signature().output_arg(0).type(), DT_BOOL);

	URL:      "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/ifaceassert",
	Requires: []*analysis.Analyzer{inspect.Analyzer},
	Run:      run,
}

// assertableTo checks whether interface v can be asserted into t. It returns
// nil on success, or the first conflicting method on failure.
func assertableTo(free *typeparams.Free, v, t types.Type) *types.Func {
	if t == nil || v == nil {

  TF_CHECK_OK(NodeBuilder("A", "NoOp").Finalize(&graph, &node));

  setenv("TF_DUMP_GRAPH_PREFIX", testing::TmpDir().c_str(), 1);
  UseMlirForGraphDump(MlirDumpConfig());
  string ret = DumpGraphToFile("tir", graph);
  ASSERT_EQ(ret, io::JoinPath(testing::TmpDir(), "tir.mlir"));

  string actual;
  TF_ASSERT_OK(ReadFileToString(Env::Default(), ret, &actual));
}

TEST(Dump, TextualIrWithOptions) {
  Graph graph(OpRegistry::Global());

TEST(FingerprintingTest, TestSerializeProto) {
  std::string many_fields_text_proto = R"pb(
    string_field: "abc123"
  )pb";
  ManyFields many_fields;
  TF_ASSERT_OK(ParseTextProto(many_fields_text_proto, &many_fields));
  ASSERT_EQ(SerializeProto(many_fields), many_fields.SerializeAsString());
}

TEST(FingerprintingTest, TestHashFieldsV2) {
  std::string cpb_file = io::JoinPath(

     * - {@code excepted} has, at a minimum, has the same number of and node names as {@actual}
     * - Where an {@code excepted} node has properties (nodeValue, types, etc.) the vales of those properties will be asserted with {@actual}
     *
     * @param actual Some or all of the model report used as the reference to verify {@code excepted}

      self.assertAllEqual(aggregator_output.output, [1.0, 1.0, 3.0, 4.0, 6.0])
      self.assertEqual(aggregator_output.min, 1.0)
      self.assertEqual(aggregator_output.max, 6.0)

      self.assertLen(aggregator_output.histogram, 512)
      self.assertEqual(sum(aggregator_output.histogram), 5)
      self.assertEqual(aggregator_output.histogram[0], 2)
      self.assertEqual(aggregator_output.histogram[128], 1)

package aes

import (
	"crypto/cipher"
	"testing"
)

// Check that the optimized implementations of cipher modes will
// be picked up correctly.

// testInterface can be asserted to check that a type originates
// from this test group.
type testInterface interface {
	InAESPackage() bool
}

// testBlock implements the cipher.Block interface and any *Able
// interfaces that need to be tested.

            // Register that we've asserted this location
            assertedLocationCount += 1

            def offsetLocation = locations.find {
                it instanceof OffsetInFileLocation
            }
            assert offsetLocation != null: "Expected a precise file location, but it was null"
            // Register that we've asserted this location
            assertedLocationCount += 1
        }