reportError("fInt16Alias", CheckEqual(fInt16Alias, fInt16Alias, nil), t)
	reportError("fInt32", CheckEqual(fInt32, fInt32, nil), t)
	reportError("fInt32Alias", CheckEqual(fInt32Alias, fInt32Alias, nil), t)
	reportError("fInt64", CheckEqual(fInt64, fInt64, nil), t)
	reportError("fInt64Alias", CheckEqual(fInt64Alias, fInt64Alias, nil), t)
	reportError("fInt8", CheckEqual(fInt8, fInt8, nil), t)

			t.Errorf("#%d bad result (got %x, want %x)", i, r, test.out)
		}
	}
	err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil)
	if err != nil {
		t.Error(err)
	}
}

func eq(a, b int32) int {
	if a == b {
		return 1
	}
	return 0
}

func TestConstantTimeEq(t *testing.T) {
	err := quick.CheckEqual(ConstantTimeEq, eq, nil)
	if err != nil {
		t.Error(err)
	}
}

		}
	}

	return nil
}

// CheckEqual looks for an input on which f and g return different results.
// It calls f and g repeatedly with arbitrary values for each argument.
// If f and g return different answers, CheckEqual returns a *[CheckEqualError]
// describing the input and the outputs.
func CheckEqual(f, g any, config *Config) error {
	if config == nil {
		config = &defaultConfig
	}

		for _, y := range testCases {
			if got, want := sqDiff(x, y), orig(x, y); got != want {
				t.Fatalf("sqDiff(%#x, %#x): got %d, want %d", x, y, got, want)
			}
		}
	}
	if err := quick.CheckEqual(orig, sqDiff, &quick.Config{MaxCountScale: 10}); err != nil {
		t.Fatal(err)
	}

// lineAt returns the line in text starting at offset offs.
func lineAt(text []byte, offs int) []byte {
	i := offs
	for i < len(text) && text[i] != '\n' {
		i++
	}
	return text[offs:i]
}

// checkEqual compares a and b.
func checkEqual(aname, bname string, a, b []byte) error {
	if bytes.Equal(a, b) {
		return nil
	}
	return errors.New(string(diff.Diff(aname, a, bname, b)))
}

	return applyCalls(new(DeepCopyMap), calls)
}

func TestMapMatchesRWMutex(t *testing.T) {
	if err := quick.CheckEqual(applyMap, applyRWMutexMap, nil); err != nil {
		t.Error(err)
	}
}

func TestMapMatchesDeepCopy(t *testing.T) {
	if err := quick.CheckEqual(applyMap, applyDeepCopyMap, nil); err != nil {
		t.Error(err)
	}
}

func TestConcurrentRange(t *testing.T) {

  TF_RETURN_IF_ERROR(GenArgShapeInfos(ps, &arg_shape_infos));
  TF_RETURN_IF_ERROR(
      CheckEqual(ps.parameters_size(), arg_index_table.size(),
                 "Arg number mismatch, proto vs. arg_index_table"));
  TF_RETURN_IF_ERROR(GenResultShapeInfos(ps, &result_shape_infos));
  TF_RETURN_IF_ERROR(
      CheckEqual(ps.result().tuple_shapes_size(), result_index_table.size(),

		for _, y := range testCases {
			if got, want := sqDiff(x, y), orig(x, y); got != want {
				t.Fatalf("sqDiff(%#x, %#x): got %d, want %d", x, y, got, want)
			}
		}
	}
	if err := quick.CheckEqual(orig, sqDiff, &quick.Config{MaxCountScale: 10}); err != nil {
		t.Fatal(err)
	}

        List<String> errors = new ArrayList<>();
        checkEquals("group", expectedId.getGroup(), actualId.getGroup(), errors);
        checkEquals("module name", expectedId.getModule(), actualId.getName(), errors);
        checkEquals("version", expectedId.getVersion(), actualId.getVersion(), errors);
        if (errors.size() > 0) {

HSPLokio/ForwardingSink;->write(Lokio/Buffer;J)V
HSPLokio/ForwardingSource;-><init>(Lokio/Source;)V
HSPLokio/ForwardingSource;->close()V
HSPLokio/GzipSource;-><init>(Lokio/Source;)V
HSPLokio/GzipSource;->checkEqual(Ljava/lang/String;II)V
HSPLokio/GzipSource;->close()V
HSPLokio/GzipSource;->read(Lokio/Buffer;J)J
HSPLokio/GzipSource;->updateCrc(Lokio/Buffer;JJ)V