/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<5d6010d9b0356775854a925e90881577>>
 */

mod refetchable_fragment;

use refetchable_fragment::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn fragment_on_interface_which_implementations_implement_node() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-interface-which-implementations-implement-node.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-interface-which-implementations-implement-node.expected");
    test_fixture(transform_fixture, "fragment-on-interface-which-implementations-implement-node.graphql", "refetchable_fragment/fixtures/fragment-on-interface-which-implementations-implement-node.expected", input, expected);
}

#[test]
fn fragment_on_interface_which_implementations_not_implement_node_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-interface-which-implementations-not-implement-node.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-interface-which-implementations-not-implement-node.invalid.expected");
    test_fixture(transform_fixture, "fragment-on-interface-which-implementations-not-implement-node.invalid.graphql", "refetchable_fragment/fixtures/fragment-on-interface-which-implementations-not-implement-node.invalid.expected", input, expected);
}

#[test]
fn fragment_on_interface_without_id() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-interface-without-id.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-interface-without-id.expected");
    test_fixture(transform_fixture, "fragment-on-interface-without-id.graphql", "refetchable_fragment/fixtures/fragment-on-interface-without-id.expected", input, expected);
}

#[test]
fn fragment_on_node_interface() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-node-interface.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-node-interface.expected");
    test_fixture(transform_fixture, "fragment-on-node-interface.graphql", "refetchable_fragment/fixtures/fragment-on-node-interface.expected", input, expected);
}

#[test]
fn fragment_on_node_interface_without_id() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-node-interface-without-id.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-node-interface-without-id.expected");
    test_fixture(transform_fixture, "fragment-on-node-interface-without-id.graphql", "refetchable_fragment/fixtures/fragment-on-node-interface-without-id.expected", input, expected);
}

#[test]
fn fragment_on_node_with_id_argument_used_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-node-with-id-argument-used.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-node-with-id-argument-used.invalid.expected");
    test_fixture(transform_fixture, "fragment-on-node-with-id-argument-used.invalid.graphql", "refetchable_fragment/fixtures/fragment-on-node-with-id-argument-used.invalid.expected", input, expected);
}

#[test]
fn fragment_on_non_node_fetchable_type() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-non-node-fetchable-type.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-non-node-fetchable-type.expected");
    test_fixture(transform_fixture, "fragment-on-non-node-fetchable-type.graphql", "refetchable_fragment/fixtures/fragment-on-non-node-fetchable-type.expected", input, expected);
}

#[test]
fn fragment_on_object_implementing_node_interface() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface.expected");
    test_fixture(transform_fixture, "fragment-on-object-implementing-node-interface.graphql", "refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface.expected", input, expected);
}

#[test]
fn fragment_on_object_implementing_node_interface_with_alias_id() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface-with-alias-id.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface-with-alias-id.expected");
    test_fixture(transform_fixture, "fragment-on-object-implementing-node-interface-with-alias-id.graphql", "refetchable_fragment/fixtures/fragment-on-object-implementing-node-interface-with-alias-id.expected", input, expected);
}

#[test]
fn fragment_on_query() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-query.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-query.expected");
    test_fixture(transform_fixture, "fragment-on-query.graphql", "refetchable_fragment/fixtures/fragment-on-query.expected", input, expected);
}

#[test]
fn fragment_on_query_with_cycle() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-query-with-cycle.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-query-with-cycle.expected");
    test_fixture(transform_fixture, "fragment-on-query-with-cycle.graphql", "refetchable_fragment/fixtures/fragment-on-query-with-cycle.expected", input, expected);
}

#[test]
fn fragment_on_query_without_query_name_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-query-without-query-name.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-query-without-query-name.invalid.expected");
    test_fixture(transform_fixture, "fragment-on-query-without-query-name.invalid.graphql", "refetchable_fragment/fixtures/fragment-on-query-without-query-name.invalid.expected", input, expected);
}

#[test]
fn fragment_on_viewer() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-on-viewer.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-on-viewer.expected");
    test_fixture(transform_fixture, "fragment-on-viewer.graphql", "refetchable_fragment/fixtures/fragment-on-viewer.expected", input, expected);
}

#[test]
fn fragment_with_args_on_object_implementing_node_interface() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-object-implementing-node-interface.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-object-implementing-node-interface.expected");
    test_fixture(transform_fixture, "fragment-with-args-on-object-implementing-node-interface.graphql", "refetchable_fragment/fixtures/fragment-with-args-on-object-implementing-node-interface.expected", input, expected);
}

#[test]
fn fragment_with_args_on_query() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-query.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-query.expected");
    test_fixture(transform_fixture, "fragment-with-args-on-query.graphql", "refetchable_fragment/fixtures/fragment-with-args-on-query.expected", input, expected);
}

#[test]
fn fragment_with_args_on_viewer() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-viewer.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-with-args-on-viewer.expected");
    test_fixture(transform_fixture, "fragment-with-args-on-viewer.graphql", "refetchable_fragment/fixtures/fragment-with-args-on-viewer.expected", input, expected);
}

#[test]
fn fragment_with_relay_plural_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/fragment-with-relay-plural.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/fragment-with-relay-plural.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-relay-plural.invalid.graphql", "refetchable_fragment/fixtures/fragment-with-relay-plural.invalid.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection_bidirectional() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-bidirectional.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-bidirectional.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection-bidirectional.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection-bidirectional.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection_literal_count_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-literal-count.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-literal-count.invalid.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection-literal-count.invalid.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection-literal-count.invalid.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection_no_cursor_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-no-cursor.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-no-cursor.invalid.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection-no-cursor.invalid.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection-no-cursor.invalid.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection_unstable_path_invalid() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-unstable-path.invalid.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-unstable-path.invalid.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection-unstable-path.invalid.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection-unstable-path.invalid.expected", input, expected);
}

#[test]
fn refetchable_fragment_with_connection_with_stream() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-with-stream.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-fragment-with-connection-with-stream.expected");
    test_fixture(transform_fixture, "refetchable-fragment-with-connection-with-stream.graphql", "refetchable_fragment/fixtures/refetchable-fragment-with-connection-with-stream.expected", input, expected);
}

#[test]
fn refetchable_interface() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-interface.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-interface.expected");
    test_fixture(transform_fixture, "refetchable-interface.graphql", "refetchable_fragment/fixtures/refetchable-interface.expected", input, expected);
}

#[test]
fn refetchable_interface_all_implementing_types_impl_node() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-interface-all-implementing-types-impl-node.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-interface-all-implementing-types-impl-node.expected");
    test_fixture(transform_fixture, "refetchable-interface-all-implementing-types-impl-node.graphql", "refetchable_fragment/fixtures/refetchable-interface-all-implementing-types-impl-node.expected", input, expected);
}

#[test]
fn refetchable_interface_but_no_implementing_types() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-interface-but-no-implementing-types.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-interface-but-no-implementing-types.expected");
    test_fixture(transform_fixture, "refetchable-interface-but-no-implementing-types.graphql", "refetchable_fragment/fixtures/refetchable-interface-but-no-implementing-types.expected", input, expected);
}

#[test]
fn refetchable_interface_some_types_impl_node() {
    let input = include_str!("refetchable_fragment/fixtures/refetchable-interface-some-types-impl-node.graphql");
    let expected = include_str!("refetchable_fragment/fixtures/refetchable-interface-some-types-impl-node.expected");
    test_fixture(transform_fixture, "refetchable-interface-some-types-impl-node.graphql", "refetchable_fragment/fixtures/refetchable-interface-some-types-impl-node.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<0ea689df4225c0f14523b6e1d62520dd>>
 */

mod relay_actor_change;

use relay_actor_change::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn actor_change_invalid() {
    let input = include_str!("relay_actor_change/fixtures/actor-change.invalid.graphql");
    let expected = include_str!("relay_actor_change/fixtures/actor-change.invalid.expected");
    test_fixture(transform_fixture, "actor-change.invalid.graphql", "relay_actor_change/fixtures/actor-change.invalid.expected", input, expected);
}

#[test]
fn actor_change_no_viewer_invalid() {
    let input = include_str!("relay_actor_change/fixtures/actor-change-no-viewer.invalid.graphql");
    let expected = include_str!("relay_actor_change/fixtures/actor-change-no-viewer.invalid.expected");
    test_fixture(transform_fixture, "actor-change-no-viewer.invalid.graphql", "relay_actor_change/fixtures/actor-change-no-viewer.invalid.expected", input, expected);
}

#[test]
fn actor_change_pluarl_invalid() {
    let input = include_str!("relay_actor_change/fixtures/actor-change-pluarl.invalid.graphql");
    let expected = include_str!("relay_actor_change/fixtures/actor-change-pluarl.invalid.expected");
    test_fixture(transform_fixture, "actor-change-pluarl.invalid.graphql", "relay_actor_change/fixtures/actor-change-pluarl.invalid.expected", input, expected);
}

#[test]
fn actor_change_wrong_viewer_invalid() {
    let input = include_str!("relay_actor_change/fixtures/actor-change-wrong-viewer.invalid.graphql");
    let expected = include_str!("relay_actor_change/fixtures/actor-change-wrong-viewer.invalid.expected");
    test_fixture(transform_fixture, "actor-change-wrong-viewer.invalid.graphql", "relay_actor_change/fixtures/actor-change-wrong-viewer.invalid.expected", input, expected);
}

#[test]
fn simple_query() {
    let input = include_str!("relay_actor_change/fixtures/simple-query.graphql");
    let expected = include_str!("relay_actor_change/fixtures/simple-query.expected");
    test_fixture(transform_fixture, "simple-query.graphql", "relay_actor_change/fixtures/simple-query.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<1d04afc08ee7547cc923bc7dab37713c>>
 */

mod relay_resolvers;

use relay_resolvers::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn field_alias() {
    let input = include_str!("relay_resolvers/fixtures/field-alias.graphql");
    let expected = include_str!("relay_resolvers/fixtures/field-alias.expected");
    test_fixture(transform_fixture, "field-alias.graphql", "relay_resolvers/fixtures/field-alias.expected", input, expected);
}

#[test]
fn fragment_spread_usage_invalid() {
    let input = include_str!("relay_resolvers/fixtures/fragment-spread-usage.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/fragment-spread-usage.invalid.expected");
    test_fixture(transform_fixture, "fragment-spread-usage.invalid.graphql", "relay_resolvers/fixtures/fragment-spread-usage.invalid.expected", input, expected);
}

#[test]
fn missing_fragment_invalid() {
    let input = include_str!("relay_resolvers/fixtures/missing-fragment.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/missing-fragment.invalid.expected");
    test_fixture(transform_fixture, "missing-fragment.invalid.graphql", "relay_resolvers/fixtures/missing-fragment.invalid.expected", input, expected);
}

#[test]
fn missing_fragment_name() {
    let input = include_str!("relay_resolvers/fixtures/missing-fragment-name.graphql");
    let expected = include_str!("relay_resolvers/fixtures/missing-fragment-name.expected");
    test_fixture(transform_fixture, "missing-fragment-name.graphql", "relay_resolvers/fixtures/missing-fragment-name.expected", input, expected);
}

#[test]
fn missing_import_path_invalid() {
    let input = include_str!("relay_resolvers/fixtures/missing-import-path.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/missing-import-path.invalid.expected");
    test_fixture(transform_fixture, "missing-import-path.invalid.graphql", "relay_resolvers/fixtures/missing-import-path.invalid.expected", input, expected);
}

#[test]
fn multiple_relay_resolvers() {
    let input = include_str!("relay_resolvers/fixtures/multiple-relay-resolvers.graphql");
    let expected = include_str!("relay_resolvers/fixtures/multiple-relay-resolvers.expected");
    test_fixture(transform_fixture, "multiple-relay-resolvers.graphql", "relay_resolvers/fixtures/multiple-relay-resolvers.expected", input, expected);
}

#[test]
fn nested_relay_resolver() {
    let input = include_str!("relay_resolvers/fixtures/nested-relay-resolver.graphql");
    let expected = include_str!("relay_resolvers/fixtures/nested-relay-resolver.expected");
    test_fixture(transform_fixture, "nested-relay-resolver.graphql", "relay_resolvers/fixtures/nested-relay-resolver.expected", input, expected);
}

#[test]
fn relay_resolver() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver.expected");
    test_fixture(transform_fixture, "relay-resolver.graphql", "relay_resolvers/fixtures/relay-resolver.expected", input, expected);
}

#[test]
fn relay_resolver_backing_client_edge() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-backing-client-edge.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-backing-client-edge.expected");
    test_fixture(transform_fixture, "relay-resolver-backing-client-edge.graphql", "relay_resolvers/fixtures/relay-resolver-backing-client-edge.expected", input, expected);
}

#[test]
fn relay_resolver_field_and_fragment_arguments() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-field-and-fragment-arguments.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-field-and-fragment-arguments.expected");
    test_fixture(transform_fixture, "relay-resolver-field-and-fragment-arguments.graphql", "relay_resolvers/fixtures/relay-resolver-field-and-fragment-arguments.expected", input, expected);
}

#[test]
fn relay_resolver_model() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-model.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-model.expected");
    test_fixture(transform_fixture, "relay-resolver-model.graphql", "relay_resolvers/fixtures/relay-resolver-model.expected", input, expected);
}

#[test]
fn relay_resolver_named_import() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-named-import.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-named-import.expected");
    test_fixture(transform_fixture, "relay-resolver-named-import.graphql", "relay_resolvers/fixtures/relay-resolver-named-import.expected", input, expected);
}

#[test]
fn relay_resolver_required() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-required.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-required.expected");
    test_fixture(transform_fixture, "relay-resolver-required.graphql", "relay_resolvers/fixtures/relay-resolver-required.expected", input, expected);
}

#[test]
fn relay_resolver_with_global_vars_directive_invalid() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-with-global-vars-directive.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-with-global-vars-directive.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-with-global-vars-directive.invalid.graphql", "relay_resolvers/fixtures/relay-resolver-with-global-vars-directive.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_with_global_vars_invalid() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-with-global-vars.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-with-global-vars.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-with-global-vars.invalid.graphql", "relay_resolvers/fixtures/relay-resolver-with-global-vars.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_within_named_inline_fragment() {
    let input = include_str!("relay_resolvers/fixtures/relay-resolver-within-named-inline-fragment.graphql");
    let expected = include_str!("relay_resolvers/fixtures/relay-resolver-within-named-inline-fragment.expected");
    test_fixture(transform_fixture, "relay-resolver-within-named-inline-fragment.graphql", "relay_resolvers/fixtures/relay-resolver-within-named-inline-fragment.expected", input, expected);
}

#[test]
fn unexpected_directive_invalid() {
    let input = include_str!("relay_resolvers/fixtures/unexpected-directive.invalid.graphql");
    let expected = include_str!("relay_resolvers/fixtures/unexpected-directive.invalid.expected");
    test_fixture(transform_fixture, "unexpected-directive.invalid.graphql", "relay_resolvers/fixtures/unexpected-directive.invalid.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<8fc748d04078d4e5388f4005efcca2ad>>
 */

mod relay_test_operation;

use relay_test_operation::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn prod_query_invalid() {
    let input = include_str!("relay_test_operation/fixtures/prod_query.invalid.graphql");
    let expected = include_str!("relay_test_operation/fixtures/prod_query.invalid.expected");
    test_fixture(transform_fixture, "prod_query.invalid.graphql", "relay_test_operation/fixtures/prod_query.invalid.expected", input, expected);
}

#[test]
fn test_client_fields_query() {
    let input = include_str!("relay_test_operation/fixtures/test_client_fields_query.graphql");
    let expected = include_str!("relay_test_operation/fixtures/test_client_fields_query.expected");
    test_fixture(transform_fixture, "test_client_fields_query.graphql", "relay_test_operation/fixtures/test_client_fields_query.expected", input, expected);
}

#[test]
fn test_query_with_enums() {
    let input = include_str!("relay_test_operation/fixtures/test_query_with_enums.graphql");
    let expected = include_str!("relay_test_operation/fixtures/test_query_with_enums.expected");
    test_fixture(transform_fixture, "test_query_with_enums.graphql", "relay_test_operation/fixtures/test_query_with_enums.expected", input, expected);
}

#[test]
fn test_simple_query() {
    let input = include_str!("relay_test_operation/fixtures/test_simple_query.graphql");
    let expected = include_str!("relay_test_operation/fixtures/test_simple_query.expected");
    test_fixture(transform_fixture, "test_simple_query.graphql", "relay_test_operation/fixtures/test_simple_query.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<d8711219e10b1f666a01fa60e6b5d967>>
 */

mod required_directive;

use required_directive::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn action_argument_omitted_invalid() {
    let input = include_str!("required_directive/fixtures/action-argument-omitted.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/action-argument-omitted.invalid.expected");
    test_fixture(transform_fixture, "action-argument-omitted.invalid.graphql", "required_directive/fixtures/action-argument-omitted.invalid.expected", input, expected);
}

#[test]
fn conflicting_required_status_across_aliased_inline_fragments() {
    let input = include_str!("required_directive/fixtures/conflicting-required-status-across-aliased-inline-fragments.graphql");
    let expected = include_str!("required_directive/fixtures/conflicting-required-status-across-aliased-inline-fragments.expected");
    test_fixture(transform_fixture, "conflicting-required-status-across-aliased-inline-fragments.graphql", "required_directive/fixtures/conflicting-required-status-across-aliased-inline-fragments.expected", input, expected);
}

#[test]
fn duplicate_field_different_actions_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-field-different-actions.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field-different-actions.invalid.expected");
    test_fixture(transform_fixture, "duplicate-field-different-actions.invalid.graphql", "required_directive/fixtures/duplicate-field-different-actions.invalid.expected", input, expected);
}

#[test]
fn duplicate_field_include_directive_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-field-include-directive.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field-include-directive.invalid.expected");
    test_fixture(transform_fixture, "duplicate-field-include-directive.invalid.graphql", "required_directive/fixtures/duplicate-field-include-directive.invalid.expected", input, expected);
}

#[test]
fn duplicate_field_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-field.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field.invalid.expected");
    test_fixture(transform_fixture, "duplicate-field.invalid.graphql", "required_directive/fixtures/duplicate-field.invalid.expected", input, expected);
}

#[test]
fn duplicate_field_nullable_parent_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-field-nullable-parent.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field-nullable-parent.invalid.expected");
    test_fixture(transform_fixture, "duplicate-field-nullable-parent.invalid.graphql", "required_directive/fixtures/duplicate-field-nullable-parent.invalid.expected", input, expected);
}

#[test]
fn duplicate_field_nullable_parent_missing_first_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-field-nullable-parent-missing-first.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field-nullable-parent-missing-first.invalid.expected");
    test_fixture(transform_fixture, "duplicate-field-nullable-parent-missing-first.invalid.graphql", "required_directive/fixtures/duplicate-field-nullable-parent-missing-first.invalid.expected", input, expected);
}

#[test]
fn duplicate_field_ussage_alias() {
    let input = include_str!("required_directive/fixtures/duplicate-field-ussage-alias.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-field-ussage-alias.expected");
    test_fixture(transform_fixture, "duplicate-field-ussage-alias.graphql", "required_directive/fixtures/duplicate-field-ussage-alias.expected", input, expected);
}

#[test]
fn duplicate_linked_field_different_actions_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-linked-field-different-actions.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-linked-field-different-actions.invalid.expected");
    test_fixture(transform_fixture, "duplicate-linked-field-different-actions.invalid.graphql", "required_directive/fixtures/duplicate-linked-field-different-actions.invalid.expected", input, expected);
}

#[test]
fn duplicate_linked_field_nullable_parent_invalid() {
    let input = include_str!("required_directive/fixtures/duplicate-linked-field-nullable-parent.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/duplicate-linked-field-nullable-parent.invalid.expected");
    test_fixture(transform_fixture, "duplicate-linked-field-nullable-parent.invalid.graphql", "required_directive/fixtures/duplicate-linked-field-nullable-parent.invalid.expected", input, expected);
}

#[test]
fn fragments_are_isolated() {
    let input = include_str!("required_directive/fixtures/fragments-are-isolated.graphql");
    let expected = include_str!("required_directive/fixtures/fragments-are-isolated.expected");
    test_fixture(transform_fixture, "fragments-are-isolated.graphql", "required_directive/fixtures/fragments-are-isolated.expected", input, expected);
}

#[test]
fn inline_directive_invalid() {
    let input = include_str!("required_directive/fixtures/inline-directive.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-directive.invalid.expected");
    test_fixture(transform_fixture, "inline-directive.invalid.graphql", "required_directive/fixtures/inline-directive.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_on_concrete_in_interface_invalid() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-concrete-in-interface.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-concrete-in-interface.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-on-concrete-in-interface.invalid.graphql", "required_directive/fixtures/inline-fragment-on-concrete-in-interface.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_on_interface_in_concrete_invalid() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-interface-in-concrete.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-interface-in-concrete.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-on-interface-in-concrete.invalid.graphql", "required_directive/fixtures/inline-fragment-on-interface-in-concrete.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_on_interface_invalid() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-interface.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-interface.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-on-interface.invalid.graphql", "required_directive/fixtures/inline-fragment-on-interface.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_on_interface_with_linked_field_invalid() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-interface-with-linked-field.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-interface-with-linked-field.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-on-interface-with-linked-field.invalid.graphql", "required_directive/fixtures/inline-fragment-on-interface-with-linked-field.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_on_interface_within_linked_field() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-interface-within-linked-field.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-interface-within-linked-field.expected");
    test_fixture(transform_fixture, "inline-fragment-on-interface-within-linked-field.graphql", "required_directive/fixtures/inline-fragment-on-interface-within-linked-field.expected", input, expected);
}

#[test]
fn inline_fragment_on_union_invalid() {
    let input = include_str!("required_directive/fixtures/inline-fragment-on-union.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/inline-fragment-on-union.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-on-union.invalid.graphql", "required_directive/fixtures/inline-fragment-on-union.invalid.expected", input, expected);
}

#[test]
fn linked_field_log() {
    let input = include_str!("required_directive/fixtures/linked-field-log.graphql");
    let expected = include_str!("required_directive/fixtures/linked-field-log.expected");
    test_fixture(transform_fixture, "linked-field-log.graphql", "required_directive/fixtures/linked-field-log.expected", input, expected);
}

#[test]
fn linked_field_no_log() {
    let input = include_str!("required_directive/fixtures/linked-field-no-log.graphql");
    let expected = include_str!("required_directive/fixtures/linked-field-no-log.expected");
    test_fixture(transform_fixture, "linked-field-no-log.graphql", "required_directive/fixtures/linked-field-no-log.expected", input, expected);
}

#[test]
fn linked_field_throw() {
    let input = include_str!("required_directive/fixtures/linked-field-throw.graphql");
    let expected = include_str!("required_directive/fixtures/linked-field-throw.expected");
    test_fixture(transform_fixture, "linked-field-throw.graphql", "required_directive/fixtures/linked-field-throw.expected", input, expected);
}

#[test]
fn log_action_bubble_to_throw_invalid() {
    let input = include_str!("required_directive/fixtures/log-action-bubble-to-throw.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/log-action-bubble-to-throw.invalid.expected");
    test_fixture(transform_fixture, "log-action-bubble-to-throw.invalid.graphql", "required_directive/fixtures/log-action-bubble-to-throw.invalid.expected", input, expected);
}

#[test]
fn multiple_required_fields_invalid() {
    let input = include_str!("required_directive/fixtures/multiple-required-fields.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/multiple-required-fields.invalid.expected");
    test_fixture(transform_fixture, "multiple-required-fields.invalid.graphql", "required_directive/fixtures/multiple-required-fields.invalid.expected", input, expected);
}

#[test]
fn none_action_bubble_to_log_across_inline_fragment_invalid() {
    let input = include_str!("required_directive/fixtures/none-action-bubble-to-log-across-inline-fragment.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/none-action-bubble-to-log-across-inline-fragment.invalid.expected");
    test_fixture(transform_fixture, "none-action-bubble-to-log-across-inline-fragment.invalid.graphql", "required_directive/fixtures/none-action-bubble-to-log-across-inline-fragment.invalid.expected", input, expected);
}

#[test]
fn none_action_bubble_to_log_invalid() {
    let input = include_str!("required_directive/fixtures/none-action-bubble-to-log.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/none-action-bubble-to-log.invalid.expected");
    test_fixture(transform_fixture, "none-action-bubble-to-log.invalid.graphql", "required_directive/fixtures/none-action-bubble-to-log.invalid.expected", input, expected);
}

#[test]
fn none_action_bubble_to_throw_invalid() {
    let input = include_str!("required_directive/fixtures/none-action-bubble-to-throw.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/none-action-bubble-to-throw.invalid.expected");
    test_fixture(transform_fixture, "none-action-bubble-to-throw.invalid.graphql", "required_directive/fixtures/none-action-bubble-to-throw.invalid.expected", input, expected);
}

#[test]
fn required_paths() {
    let input = include_str!("required_directive/fixtures/required-paths.graphql");
    let expected = include_str!("required_directive/fixtures/required-paths.expected");
    test_fixture(transform_fixture, "required-paths.graphql", "required_directive/fixtures/required-paths.expected", input, expected);
}

#[test]
fn required_with_different_actions_invalid() {
    let input = include_str!("required_directive/fixtures/required-with-different-actions.invalid.graphql");
    let expected = include_str!("required_directive/fixtures/required-with-different-actions.invalid.expected");
    test_fixture(transform_fixture, "required-with-different-actions.invalid.graphql", "required_directive/fixtures/required-with-different-actions.invalid.expected", input, expected);
}

#[test]
fn scalar_field_log() {
    let input = include_str!("required_directive/fixtures/scalar-field-log.graphql");
    let expected = include_str!("required_directive/fixtures/scalar-field-log.expected");
    test_fixture(transform_fixture, "scalar-field-log.graphql", "required_directive/fixtures/scalar-field-log.expected", input, expected);
}

#[test]
fn scalar_field_no_log() {
    let input = include_str!("required_directive/fixtures/scalar-field-no-log.graphql");
    let expected = include_str!("required_directive/fixtures/scalar-field-no-log.expected");
    test_fixture(transform_fixture, "scalar-field-no-log.graphql", "required_directive/fixtures/scalar-field-no-log.expected", input, expected);
}

#[test]
fn scalar_field_throw() {
    let input = include_str!("required_directive/fixtures/scalar-field-throw.graphql");
    let expected = include_str!("required_directive/fixtures/scalar-field-throw.expected");
    test_fixture(transform_fixture, "scalar-field-throw.graphql", "required_directive/fixtures/scalar-field-throw.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<63a5e6c07739f57b58aebaf6414d3d8f>>
 */

mod skip_client_extensions;

use skip_client_extensions::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn client_conditions() {
    let input = include_str!("skip_client_extensions/fixtures/client-conditions.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-conditions.expected");
    test_fixture(transform_fixture, "client-conditions.graphql", "skip_client_extensions/fixtures/client-conditions.expected", input, expected);
}

#[test]
fn client_directives() {
    let input = include_str!("skip_client_extensions/fixtures/client-directives.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-directives.expected");
    test_fixture(transform_fixture, "client-directives.graphql", "skip_client_extensions/fixtures/client-directives.expected", input, expected);
}

#[test]
fn client_fields_in_inline_fragments() {
    let input = include_str!("skip_client_extensions/fixtures/client-fields-in-inline-fragments.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-fields-in-inline-fragments.expected");
    test_fixture(transform_fixture, "client-fields-in-inline-fragments.graphql", "skip_client_extensions/fixtures/client-fields-in-inline-fragments.expected", input, expected);
}

#[test]
fn client_fields_of_client_type() {
    let input = include_str!("skip_client_extensions/fixtures/client-fields-of-client-type.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-fields-of-client-type.expected");
    test_fixture(transform_fixture, "client-fields-of-client-type.graphql", "skip_client_extensions/fixtures/client-fields-of-client-type.expected", input, expected);
}

#[test]
fn client_fields_on_roots() {
    let input = include_str!("skip_client_extensions/fixtures/client-fields-on-roots.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-fields-on-roots.expected");
    test_fixture(transform_fixture, "client-fields-on-roots.graphql", "skip_client_extensions/fixtures/client-fields-on-roots.expected", input, expected);
}

#[test]
fn client_fragment_spreads() {
    let input = include_str!("skip_client_extensions/fixtures/client-fragment-spreads.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-fragment-spreads.expected");
    test_fixture(transform_fixture, "client-fragment-spreads.graphql", "skip_client_extensions/fixtures/client-fragment-spreads.expected", input, expected);
}

#[test]
fn client_fragment_spreads_in_query() {
    let input = include_str!("skip_client_extensions/fixtures/client-fragment-spreads-in-query.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-fragment-spreads-in-query.expected");
    test_fixture(transform_fixture, "client-fragment-spreads-in-query.graphql", "skip_client_extensions/fixtures/client-fragment-spreads-in-query.expected", input, expected);
}

#[test]
fn client_inline_fragments() {
    let input = include_str!("skip_client_extensions/fixtures/client-inline-fragments.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-inline-fragments.expected");
    test_fixture(transform_fixture, "client-inline-fragments.graphql", "skip_client_extensions/fixtures/client-inline-fragments.expected", input, expected);
}

#[test]
fn client_inline_fragments_in_query() {
    let input = include_str!("skip_client_extensions/fixtures/client-inline-fragments-in-query.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-inline-fragments-in-query.expected");
    test_fixture(transform_fixture, "client-inline-fragments-in-query.graphql", "skip_client_extensions/fixtures/client-inline-fragments-in-query.expected", input, expected);
}

#[test]
fn client_linked_fields() {
    let input = include_str!("skip_client_extensions/fixtures/client-linked-fields.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-linked-fields.expected");
    test_fixture(transform_fixture, "client-linked-fields.graphql", "skip_client_extensions/fixtures/client-linked-fields.expected", input, expected);
}

#[test]
fn client_scalar_fields() {
    let input = include_str!("skip_client_extensions/fixtures/client-scalar-fields.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/client-scalar-fields.expected");
    test_fixture(transform_fixture, "client-scalar-fields.graphql", "skip_client_extensions/fixtures/client-scalar-fields.expected", input, expected);
}

#[test]
fn query_with_only_client_fields() {
    let input = include_str!("skip_client_extensions/fixtures/query-with-only-client-fields.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/query-with-only-client-fields.expected");
    test_fixture(transform_fixture, "query-with-only-client-fields.graphql", "skip_client_extensions/fixtures/query-with-only-client-fields.expected", input, expected);
}

#[test]
fn relay_resolver_metadata() {
    let input = include_str!("skip_client_extensions/fixtures/relay-resolver-metadata.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/relay-resolver-metadata.expected");
    test_fixture(transform_fixture, "relay-resolver-metadata.graphql", "skip_client_extensions/fixtures/relay-resolver-metadata.expected", input, expected);
}

#[test]
fn sibling_client_selections() {
    let input = include_str!("skip_client_extensions/fixtures/sibling-client-selections.graphql");
    let expected = include_str!("skip_client_extensions/fixtures/sibling-client-selections.expected");
    test_fixture(transform_fixture, "sibling-client-selections.graphql", "skip_client_extensions/fixtures/sibling-client-selections.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<550822f58e01f87929cf6bd8be28dc4a>>
 */

mod skip_redundant_nodes;

use skip_redundant_nodes::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn dont_skip_different_ids() {
    let input = include_str!("skip_redundant_nodes/fixtures/dont-skip-different-ids.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/dont-skip-different-ids.expected");
    test_fixture(transform_fixture, "dont-skip-different-ids.graphql", "skip_redundant_nodes/fixtures/dont-skip-different-ids.expected", input, expected);
}

#[test]
fn dont_skip_nested_fields_across_fragments() {
    let input = include_str!("skip_redundant_nodes/fixtures/dont-skip-nested-fields-across-fragments.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/dont-skip-nested-fields-across-fragments.expected");
    test_fixture(transform_fixture, "dont-skip-nested-fields-across-fragments.graphql", "skip_redundant_nodes/fixtures/dont-skip-nested-fields-across-fragments.expected", input, expected);
}

#[test]
fn dont_skip_with_inline_on_diffent_types() {
    let input = include_str!("skip_redundant_nodes/fixtures/dont-skip-with-inline-on-diffent-types.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/dont-skip-with-inline-on-diffent-types.expected");
    test_fixture(transform_fixture, "dont-skip-with-inline-on-diffent-types.graphql", "skip_redundant_nodes/fixtures/dont-skip-with-inline-on-diffent-types.expected", input, expected);
}

#[test]
fn redundant_selection_in_inline_fragments() {
    let input = include_str!("skip_redundant_nodes/fixtures/redundant-selection-in-inline-fragments.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/redundant-selection-in-inline-fragments.expected");
    test_fixture(transform_fixture, "redundant-selection-in-inline-fragments.graphql", "skip_redundant_nodes/fixtures/redundant-selection-in-inline-fragments.expected", input, expected);
}

#[test]
fn skip_nested_linked_fields() {
    let input = include_str!("skip_redundant_nodes/fixtures/skip-nested-linked-fields.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skip-nested-linked-fields.expected");
    test_fixture(transform_fixture, "skip-nested-linked-fields.graphql", "skip_redundant_nodes/fixtures/skip-nested-linked-fields.expected", input, expected);
}

#[test]
fn skips_nested_fields() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-nested-fields.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-nested-fields.expected");
    test_fixture(transform_fixture, "skips-nested-fields.graphql", "skip_redundant_nodes/fixtures/skips-nested-fields.expected", input, expected);
}

#[test]
fn skips_with_client_extensions() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-with-client-extensions.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-with-client-extensions.expected");
    test_fixture(transform_fixture, "skips-with-client-extensions.graphql", "skip_redundant_nodes/fixtures/skips-with-client-extensions.expected", input, expected);
}

#[test]
fn skips_with_fragment() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-with-fragment.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-with-fragment.expected");
    test_fixture(transform_fixture, "skips-with-fragment.graphql", "skip_redundant_nodes/fixtures/skips-with-fragment.expected", input, expected);
}

#[test]
fn skips_with_module() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-with-module.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-with-module.expected");
    test_fixture(transform_fixture, "skips-with-module.graphql", "skip_redundant_nodes/fixtures/skips-with-module.expected", input, expected);
}

#[test]
fn skips_with_outer_fields_first() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-with-outer-fields-first.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-with-outer-fields-first.expected");
    test_fixture(transform_fixture, "skips-with-outer-fields-first.graphql", "skip_redundant_nodes/fixtures/skips-with-outer-fields-first.expected", input, expected);
}

#[test]
fn skips_with_outer_fields_last() {
    let input = include_str!("skip_redundant_nodes/fixtures/skips-with-outer-fields-last.graphql");
    let expected = include_str!("skip_redundant_nodes/fixtures/skips-with-outer-fields-last.expected");
    test_fixture(transform_fixture, "skips-with-outer-fields-last.graphql", "skip_redundant_nodes/fixtures/skips-with-outer-fields-last.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<92728b5919d760a08def5a55c9b9e71e>>
 */

mod skip_unreachable_nodes;

use skip_unreachable_nodes::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn keeps_other_fields() {
    let input = include_str!("skip_unreachable_nodes/fixtures/keeps-other-fields.graphql");
    let expected = include_str!("skip_unreachable_nodes/fixtures/keeps-other-fields.expected");
    test_fixture(transform_fixture, "keeps-other-fields.graphql", "skip_unreachable_nodes/fixtures/keeps-other-fields.expected", input, expected);
}

#[test]
fn removes_include_false() {
    let input = include_str!("skip_unreachable_nodes/fixtures/removes-include-false.graphql");
    let expected = include_str!("skip_unreachable_nodes/fixtures/removes-include-false.expected");
    test_fixture(transform_fixture, "removes-include-false.graphql", "skip_unreachable_nodes/fixtures/removes-include-false.expected", input, expected);
}

#[test]
fn removes_recursively_empty_definitions() {
    let input = include_str!("skip_unreachable_nodes/fixtures/removes-recursively-empty-definitions.graphql");
    let expected = include_str!("skip_unreachable_nodes/fixtures/removes-recursively-empty-definitions.expected");
    test_fixture(transform_fixture, "removes-recursively-empty-definitions.graphql", "skip_unreachable_nodes/fixtures/removes-recursively-empty-definitions.expected", input, expected);
}

#[test]
fn removes_skip_true() {
    let input = include_str!("skip_unreachable_nodes/fixtures/removes-skip-true.graphql");
    let expected = include_str!("skip_unreachable_nodes/fixtures/removes-skip-true.expected");
    test_fixture(transform_fixture, "removes-skip-true.graphql", "skip_unreachable_nodes/fixtures/removes-skip-true.expected", input, expected);
}

#[test]
fn skipped_fragment() {
    let input = include_str!("skip_unreachable_nodes/fixtures/skipped-fragment.graphql");
    let expected = include_str!("skip_unreachable_nodes/fixtures/skipped-fragment.expected");
    test_fixture(transform_fixture, "skipped-fragment.graphql", "skip_unreachable_nodes/fixtures/skipped-fragment.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<d037736d5049654d3573e54611d9e683>>
 */

mod skip_unused_variables;

use skip_unused_variables::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn kitchen_sink() {
    let input = include_str!("skip_unused_variables/fixtures/kitchen-sink.graphql");
    let expected = include_str!("skip_unused_variables/fixtures/kitchen-sink.expected");
    test_fixture(transform_fixture, "kitchen-sink.graphql", "skip_unused_variables/fixtures/kitchen-sink.expected", input, expected);
}

#[test]
fn non_nullable_variable_with_default_invalid() {
    let input = include_str!("skip_unused_variables/fixtures/non-nullable-variable-with-default.invalid.graphql");
    let expected = include_str!("skip_unused_variables/fixtures/non-nullable-variable-with-default.invalid.expected");
    test_fixture(transform_fixture, "non-nullable-variable-with-default.invalid.graphql", "skip_unused_variables/fixtures/non-nullable-variable-with-default.invalid.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<d5c1c2d3a31832a10a654919a68a7df3>>
 */

mod sort_selections;

use sort_selections::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn sort_selections_transform() {
    let input = include_str!("sort_selections/fixtures/sort-selections-transform.graphql");
    let expected = include_str!("sort_selections/fixtures/sort-selections-transform.expected");
    test_fixture(transform_fixture, "sort-selections-transform.graphql", "sort_selections/fixtures/sort-selections-transform.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<bcf2937e99ed9db01839f955383dbbcd>>
 */

mod subscription_transform;

use subscription_transform::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn subscription_transform() {
    let input = include_str!("subscription_transform/fixtures/subscription_transform.graphql");
    let expected = include_str!("subscription_transform/fixtures/subscription_transform.expected");
    test_fixture(transform_fixture, "subscription_transform.graphql", "subscription_transform/fixtures/subscription_transform.expected", input, expected);
}

#[test]
fn subscription_transform_noop_no_js_field() {
    let input = include_str!("subscription_transform/fixtures/subscription_transform_noop_no_js_field.graphql");
    let expected = include_str!("subscription_transform/fixtures/subscription_transform_noop_no_js_field.expected");
    test_fixture(transform_fixture, "subscription_transform_noop_no_js_field.graphql", "subscription_transform/fixtures/subscription_transform_noop_no_js_field.expected", input, expected);
}

#[test]
fn subscription_transform_noop_no_spread() {
    let input = include_str!("subscription_transform/fixtures/subscription_transform_noop_no_spread.graphql");
    let expected = include_str!("subscription_transform/fixtures/subscription_transform_noop_no_spread.expected");
    test_fixture(transform_fixture, "subscription_transform_noop_no_spread.graphql", "subscription_transform/fixtures/subscription_transform_noop_no_spread.expected", input, expected);
}

#[test]
fn subscription_transform_noop_two_selections() {
    let input = include_str!("subscription_transform/fixtures/subscription_transform_noop_two_selections.graphql");
    let expected = include_str!("subscription_transform/fixtures/subscription_transform_noop_two_selections.expected");
    test_fixture(transform_fixture, "subscription_transform_noop_two_selections.graphql", "subscription_transform/fixtures/subscription_transform_noop_two_selections.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<5eb995d94b94b43b9433675f2d83cc6f>>
 */

mod transform_connections;

use transform_connections::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn connection() {
    let input = include_str!("transform_connections/fixtures/connection.graphql");
    let expected = include_str!("transform_connections/fixtures/connection.expected");
    test_fixture(transform_fixture, "connection.graphql", "transform_connections/fixtures/connection.expected", input, expected);
}

#[test]
fn connection_directions() {
    let input = include_str!("transform_connections/fixtures/connection-directions.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-directions.expected");
    test_fixture(transform_fixture, "connection-directions.graphql", "transform_connections/fixtures/connection-directions.expected", input, expected);
}

#[test]
fn connection_empty_filters() {
    let input = include_str!("transform_connections/fixtures/connection-empty-filters.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-empty-filters.expected");
    test_fixture(transform_fixture, "connection-empty-filters.graphql", "transform_connections/fixtures/connection-empty-filters.expected", input, expected);
}

#[test]
fn connection_filters() {
    let input = include_str!("transform_connections/fixtures/connection-filters.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-filters.expected");
    test_fixture(transform_fixture, "connection-filters.graphql", "transform_connections/fixtures/connection-filters.expected", input, expected);
}

#[test]
fn connection_generate_filters() {
    let input = include_str!("transform_connections/fixtures/connection-generate-filters.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-generate-filters.expected");
    test_fixture(transform_fixture, "connection-generate-filters.graphql", "transform_connections/fixtures/connection-generate-filters.expected", input, expected);
}

#[test]
fn connection_with_aliased_edges_page_info() {
    let input = include_str!("transform_connections/fixtures/connection-with-aliased-edges-page-info.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-with-aliased-edges-page-info.expected");
    test_fixture(transform_fixture, "connection-with-aliased-edges-page-info.graphql", "transform_connections/fixtures/connection-with-aliased-edges-page-info.expected", input, expected);
}

#[test]
fn connection_with_custom_handler() {
    let input = include_str!("transform_connections/fixtures/connection-with-custom-handler.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-with-custom-handler.expected");
    test_fixture(transform_fixture, "connection-with-custom-handler.graphql", "transform_connections/fixtures/connection-with-custom-handler.expected", input, expected);
}

#[test]
fn connection_with_page_info() {
    let input = include_str!("transform_connections/fixtures/connection-with-page-info.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-with-page-info.expected");
    test_fixture(transform_fixture, "connection-with-page-info.graphql", "transform_connections/fixtures/connection-with-page-info.expected", input, expected);
}

#[test]
fn connection_with_variables() {
    let input = include_str!("transform_connections/fixtures/connection-with-variables.graphql");
    let expected = include_str!("transform_connections/fixtures/connection-with-variables.expected");
    test_fixture(transform_fixture, "connection-with-variables.graphql", "transform_connections/fixtures/connection-with-variables.expected", input, expected);
}

#[test]
fn stream_connection() {
    let input = include_str!("transform_connections/fixtures/stream-connection.graphql");
    let expected = include_str!("transform_connections/fixtures/stream-connection.expected");
    test_fixture(transform_fixture, "stream-connection.graphql", "transform_connections/fixtures/stream-connection.expected", input, expected);
}

#[test]
fn stream_connection_no_label() {
    let input = include_str!("transform_connections/fixtures/stream-connection-no-label.graphql");
    let expected = include_str!("transform_connections/fixtures/stream-connection-no-label.expected");
    test_fixture(transform_fixture, "stream-connection-no-label.graphql", "transform_connections/fixtures/stream-connection-no-label.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<04bba5dd6952e840a3ddf09a94de7667>>
 */

mod updatable_directive;

use updatable_directive::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn assignable_fragment_spread_not_subtype_invalid() {
    let input = include_str!("updatable_directive/fixtures/assignable-fragment-spread-not-subtype.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/assignable-fragment-spread-not-subtype.invalid.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-not-subtype.invalid.graphql", "updatable_directive/fixtures/assignable-fragment-spread-not-subtype.invalid.expected", input, expected);
}

#[test]
fn assignable_fragment_spreads() {
    let input = include_str!("updatable_directive/fixtures/assignable-fragment-spreads.graphql");
    let expected = include_str!("updatable_directive/fixtures/assignable-fragment-spreads.expected");
    test_fixture(transform_fixture, "assignable-fragment-spreads.graphql", "updatable_directive/fixtures/assignable-fragment-spreads.expected", input, expected);
}

#[test]
fn client_side_updatable() {
    let input = include_str!("updatable_directive/fixtures/client-side-updatable.graphql");
    let expected = include_str!("updatable_directive/fixtures/client-side-updatable.expected");
    test_fixture(transform_fixture, "client-side-updatable.graphql", "updatable_directive/fixtures/client-side-updatable.expected", input, expected);
}

#[test]
fn directive_fragment_spread_invalid() {
    let input = include_str!("updatable_directive/fixtures/directive-fragment-spread.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/directive-fragment-spread.invalid.expected");
    test_fixture(transform_fixture, "directive-fragment-spread.invalid.graphql", "updatable_directive/fixtures/directive-fragment-spread.invalid.expected", input, expected);
}

#[test]
fn directive_inline_fragment_invalid() {
    let input = include_str!("updatable_directive/fixtures/directive-inline-fragment.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/directive-inline-fragment.invalid.expected");
    test_fixture(transform_fixture, "directive-inline-fragment.invalid.graphql", "updatable_directive/fixtures/directive-inline-fragment.invalid.expected", input, expected);
}

#[test]
fn directive_linked_field_invalid() {
    let input = include_str!("updatable_directive/fixtures/directive-linked-field.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/directive-linked-field.invalid.expected");
    test_fixture(transform_fixture, "directive-linked-field.invalid.graphql", "updatable_directive/fixtures/directive-linked-field.invalid.expected", input, expected);
}

#[test]
fn directive_query_invalid() {
    let input = include_str!("updatable_directive/fixtures/directive-query.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/directive-query.invalid.expected");
    test_fixture(transform_fixture, "directive-query.invalid.graphql", "updatable_directive/fixtures/directive-query.invalid.expected", input, expected);
}

#[test]
fn directive_scalar_field_invalid() {
    let input = include_str!("updatable_directive/fixtures/directive-scalar-field.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/directive-scalar-field.invalid.expected");
    test_fixture(transform_fixture, "directive-scalar-field.invalid.graphql", "updatable_directive/fixtures/directive-scalar-field.invalid.expected", input, expected);
}

#[test]
fn doubly_nested_fragment_spread_invalid() {
    let input = include_str!("updatable_directive/fixtures/doubly-nested-fragment-spread.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/doubly-nested-fragment-spread.invalid.expected");
    test_fixture(transform_fixture, "doubly-nested-fragment-spread.invalid.graphql", "updatable_directive/fixtures/doubly-nested-fragment-spread.invalid.expected", input, expected);
}

#[test]
fn include_invalid() {
    let input = include_str!("updatable_directive/fixtures/include.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/include.invalid.expected");
    test_fixture(transform_fixture, "include.invalid.graphql", "updatable_directive/fixtures/include.invalid.expected", input, expected);
}

#[test]
fn inline_fragment() {
    let input = include_str!("updatable_directive/fixtures/inline-fragment.graphql");
    let expected = include_str!("updatable_directive/fixtures/inline-fragment.expected");
    test_fixture(transform_fixture, "inline-fragment.graphql", "updatable_directive/fixtures/inline-fragment.expected", input, expected);
}

#[test]
fn inline_fragment_concrete_type_to_concrete_type_invalid() {
    let input = include_str!("updatable_directive/fixtures/inline-fragment-concrete-type-to-concrete-type.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/inline-fragment-concrete-type-to-concrete-type.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-concrete-type-to-concrete-type.invalid.graphql", "updatable_directive/fixtures/inline-fragment-concrete-type-to-concrete-type.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_concrete_type_to_interface_invalid() {
    let input = include_str!("updatable_directive/fixtures/inline-fragment-concrete-type-to-interface.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/inline-fragment-concrete-type-to-interface.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-concrete-type-to-interface.invalid.graphql", "updatable_directive/fixtures/inline-fragment-concrete-type-to-interface.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_interface_to_interface_invalid() {
    let input = include_str!("updatable_directive/fixtures/inline-fragment-interface-to-interface.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/inline-fragment-interface-to-interface.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-interface-to-interface.invalid.graphql", "updatable_directive/fixtures/inline-fragment-interface-to-interface.invalid.expected", input, expected);
}

#[test]
fn inline_fragment_redundant_invalid() {
    let input = include_str!("updatable_directive/fixtures/inline-fragment-redundant.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/inline-fragment-redundant.invalid.expected");
    test_fixture(transform_fixture, "inline-fragment-redundant.invalid.graphql", "updatable_directive/fixtures/inline-fragment-redundant.invalid.expected", input, expected);
}

#[test]
fn non_assignable_fragment_spreads_invalid() {
    let input = include_str!("updatable_directive/fixtures/non-assignable-fragment-spreads.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/non-assignable-fragment-spreads.invalid.expected");
    test_fixture(transform_fixture, "non-assignable-fragment-spreads.invalid.graphql", "updatable_directive/fixtures/non-assignable-fragment-spreads.invalid.expected", input, expected);
}

#[test]
fn required_invalid() {
    let input = include_str!("updatable_directive/fixtures/required.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/required.invalid.expected");
    test_fixture(transform_fixture, "required.invalid.graphql", "updatable_directive/fixtures/required.invalid.expected", input, expected);
}

#[test]
fn resolver_linked_invalid() {
    let input = include_str!("updatable_directive/fixtures/resolver-linked.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/resolver-linked.invalid.expected");
    test_fixture(transform_fixture, "resolver-linked.invalid.graphql", "updatable_directive/fixtures/resolver-linked.invalid.expected", input, expected);
}

#[test]
fn resolver_scalar_invalid() {
    let input = include_str!("updatable_directive/fixtures/resolver-scalar.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/resolver-scalar.invalid.expected");
    test_fixture(transform_fixture, "resolver-scalar.invalid.graphql", "updatable_directive/fixtures/resolver-scalar.invalid.expected", input, expected);
}

#[test]
fn skip_invalid() {
    let input = include_str!("updatable_directive/fixtures/skip.invalid.graphql");
    let expected = include_str!("updatable_directive/fixtures/skip.invalid.expected");
    test_fixture(transform_fixture, "skip.invalid.graphql", "updatable_directive/fixtures/skip.invalid.expected", input, expected);
}

#[test]
fn type_narrowing() {
    let input = include_str!("updatable_directive/fixtures/type-narrowing.graphql");
    let expected = include_str!("updatable_directive/fixtures/type-narrowing.expected");
    test_fixture(transform_fixture, "type-narrowing.graphql", "updatable_directive/fixtures/type-narrowing.expected", input, expected);
}

#[test]
fn updatable_fragment() {
    let input = include_str!("updatable_directive/fixtures/updatable-fragment.graphql");
    let expected = include_str!("updatable_directive/fixtures/updatable-fragment.expected");
    test_fixture(transform_fixture, "updatable-fragment.graphql", "updatable_directive/fixtures/updatable-fragment.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<18869a0e4b56456538b89f35c173d802>>
 */

mod updatable_fragment_spread;

use updatable_fragment_spread::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn updatable_fragment_spread_abstract_in_concrete() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_concrete.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_concrete.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_abstract_in_concrete.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_concrete.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_abstract_in_different_non_extending_abstract_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_different_non_extending_abstract.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_different_non_extending_abstract.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_abstract_in_different_non_extending_abstract.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_different_non_extending_abstract.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_abstract_in_same_abstract() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_same_abstract.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_same_abstract.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_abstract_in_same_abstract.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_abstract_in_same_abstract.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_concrete_in_different_concrete_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_different_concrete.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_different_concrete.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_concrete_in_different_concrete.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_different_concrete.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_concrete_in_matching_abstract_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_matching_abstract.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_matching_abstract.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_concrete_in_matching_abstract.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_matching_abstract.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_concrete_in_non_matching_abstract_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_non_matching_abstract.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_non_matching_abstract.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_concrete_in_non_matching_abstract.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_non_matching_abstract.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_concrete_in_same_concrete() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_same_concrete.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_same_concrete.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_concrete_in_same_concrete.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_concrete_in_same_concrete.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_condition_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_condition.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_condition.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_condition.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_condition.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_abstract_type_condition_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_abstract_type_condition.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_abstract_type_condition.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_abstract_type_condition.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_abstract_type_condition.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_no_typename_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_no_typename.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_no_typename.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_no_typename.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_no_typename.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_redundant_type_condition_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_redundant_type_condition.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_redundant_type_condition.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_redundant_type_condition.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_redundant_type_condition.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_alias_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_alias.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_alias.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_alias.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_alias.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_condition_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_condition.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_condition.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_condition.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_condition.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_directives_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_directives.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_directives.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_directives.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_typename_with_directives.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_with_fragment_spread_directives() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_with_fragment_spread_directives.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_with_fragment_spread_directives.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_with_fragment_spread_directives.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_with_fragment_spread_directives.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type_invalid_1() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_1.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_1.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_1.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_1.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type_invalid_2() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_2.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_2.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_2.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_2.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type_invalid_3() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_3.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_3.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_3.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_3.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type_invalid_4() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_4.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_4.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_4.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_other_selections_wrong_type.invalid_4.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_with_abstract_type_condition_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_with_abstract_type_condition.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_with_abstract_type_condition.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_with_abstract_type_condition.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_with_abstract_type_condition.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_in_inline_fragment_without_typename_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_without_typename.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_without_typename.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_in_inline_fragment_without_typename.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_in_inline_fragment_without_typename.invalid.expected", input, expected);
}

#[test]
fn updatable_fragment_spread_top_level_invalid() {
    let input = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_top_level.invalid.graphql");
    let expected = include_str!("updatable_fragment_spread/fixtures/updatable_fragment_spread_top_level.invalid.expected");
    test_fixture(transform_fixture, "updatable_fragment_spread_top_level.invalid.graphql", "updatable_fragment_spread/fixtures/updatable_fragment_spread_top_level.invalid.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<e5c9098776729989646744799f3989a5>>
 */

mod validate_connections_schema;

use validate_connections_schema::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn connection_invalid_edge_type_invalid() {
    let input = include_str!("validate_connections_schema/fixtures/connection-invalid-edge-type.invalid.graphql");
    let expected = include_str!("validate_connections_schema/fixtures/connection-invalid-edge-type.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-edge-type.invalid.graphql", "validate_connections_schema/fixtures/connection-invalid-edge-type.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_edges_field_invalid() {
    let input = include_str!("validate_connections_schema/fixtures/connection-invalid-edges-field.invalid.graphql");
    let expected = include_str!("validate_connections_schema/fixtures/connection-invalid-edges-field.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-edges-field.invalid.graphql", "validate_connections_schema/fixtures/connection-invalid-edges-field.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_edges_list_type_invalid() {
    let input = include_str!("validate_connections_schema/fixtures/connection-invalid-edges-list-type.invalid.graphql");
    let expected = include_str!("validate_connections_schema/fixtures/connection-invalid-edges-list-type.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-edges-list-type.invalid.graphql", "validate_connections_schema/fixtures/connection-invalid-edges-list-type.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_no_page_info_invalid() {
    let input = include_str!("validate_connections_schema/fixtures/connection-invalid-no-page-info.invalid.graphql");
    let expected = include_str!("validate_connections_schema/fixtures/connection-invalid-no-page-info.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-no-page-info.invalid.graphql", "validate_connections_schema/fixtures/connection-invalid-no-page-info.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_page_info_invalid() {
    let input = include_str!("validate_connections_schema/fixtures/connection-invalid-page-info.invalid.graphql");
    let expected = include_str!("validate_connections_schema/fixtures/connection-invalid-page-info.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-page-info.invalid.graphql", "validate_connections_schema/fixtures/connection-invalid-page-info.invalid.expected", input, expected);
}


/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @generated SignedSource<<5700a721e31a6f0171af5d09f9bf1592>>
 */

mod validate_connections;

use validate_connections::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn connection() {
    let input = include_str!("validate_connections/fixtures/connection.graphql");
    let expected = include_str!("validate_connections/fixtures/connection.expected");
    test_fixture(transform_fixture, "connection.graphql", "validate_connections/fixtures/connection.expected", input, expected);
}

#[test]
fn connection_directions() {
    let input = include_str!("validate_connections/fixtures/connection-directions.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-directions.expected");
    test_fixture(transform_fixture, "connection-directions.graphql", "validate_connections/fixtures/connection-directions.expected", input, expected);
}

#[test]
fn connection_empty_filters() {
    let input = include_str!("validate_connections/fixtures/connection-empty-filters.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-empty-filters.expected");
    test_fixture(transform_fixture, "connection-empty-filters.graphql", "validate_connections/fixtures/connection-empty-filters.expected", input, expected);
}

#[test]
fn connection_filters() {
    let input = include_str!("validate_connections/fixtures/connection-filters.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-filters.expected");
    test_fixture(transform_fixture, "connection-filters.graphql", "validate_connections/fixtures/connection-filters.expected", input, expected);
}

#[test]
fn connection_filters_not_a_string() {
    let input = include_str!("validate_connections/fixtures/connection-filters-not-a-string.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-filters-not-a-string.expected");
    test_fixture(transform_fixture, "connection-filters-not-a-string.graphql", "validate_connections/fixtures/connection-filters-not-a-string.expected", input, expected);
}

#[test]
fn connection_filters_not_an_arg() {
    let input = include_str!("validate_connections/fixtures/connection-filters-not-an-arg.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-filters-not-an-arg.expected");
    test_fixture(transform_fixture, "connection-filters-not-an-arg.graphql", "validate_connections/fixtures/connection-filters-not-an-arg.expected", input, expected);
}

#[test]
fn connection_filters_null_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-filters-null.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-filters-null.invalid.expected");
    test_fixture(transform_fixture, "connection-filters-null.invalid.graphql", "validate_connections/fixtures/connection-filters-null.invalid.expected", input, expected);
}

#[test]
fn connection_generate_filters() {
    let input = include_str!("validate_connections/fixtures/connection-generate-filters.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-generate-filters.expected");
    test_fixture(transform_fixture, "connection-generate-filters.graphql", "validate_connections/fixtures/connection-generate-filters.expected", input, expected);
}

#[test]
fn connection_invalid_key_name_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-invalid-key-name.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-invalid-key-name.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-key-name.invalid.graphql", "validate_connections/fixtures/connection-invalid-key-name.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_key_type_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-invalid-key-type.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-invalid-key-type.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-key-type.invalid.graphql", "validate_connections/fixtures/connection-invalid-key-type.invalid.expected", input, expected);
}

#[test]
fn connection_invalid_type_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-invalid-type.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-invalid-type.invalid.expected");
    test_fixture(transform_fixture, "connection-invalid-type.invalid.graphql", "validate_connections/fixtures/connection-invalid-type.invalid.expected", input, expected);
}

#[test]
fn connection_missing_edges_selection_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-missing-edges-selection.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-missing-edges-selection.invalid.expected");
    test_fixture(transform_fixture, "connection-missing-edges-selection.invalid.graphql", "validate_connections/fixtures/connection-missing-edges-selection.invalid.expected", input, expected);
}

#[test]
fn connection_missing_first_arg_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-missing-first-arg.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-missing-first-arg.invalid.expected");
    test_fixture(transform_fixture, "connection-missing-first-arg.invalid.graphql", "validate_connections/fixtures/connection-missing-first-arg.invalid.expected", input, expected);
}

#[test]
fn connection_with_aliased_edges_page_info() {
    let input = include_str!("validate_connections/fixtures/connection-with-aliased-edges-page-info.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-with-aliased-edges-page-info.expected");
    test_fixture(transform_fixture, "connection-with-aliased-edges-page-info.graphql", "validate_connections/fixtures/connection-with-aliased-edges-page-info.expected", input, expected);
}

#[test]
fn connection_with_custom_handler() {
    let input = include_str!("validate_connections/fixtures/connection-with-custom-handler.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-with-custom-handler.expected");
    test_fixture(transform_fixture, "connection-with-custom-handler.graphql", "validate_connections/fixtures/connection-with-custom-handler.expected", input, expected);
}

#[test]
fn connection_with_invalid_custom_handler_invalid() {
    let input = include_str!("validate_connections/fixtures/connection-with-invalid-custom-handler.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-with-invalid-custom-handler.invalid.expected");
    test_fixture(transform_fixture, "connection-with-invalid-custom-handler.invalid.graphql", "validate_connections/fixtures/connection-with-invalid-custom-handler.invalid.expected", input, expected);
}

#[test]
fn connection_with_page_info() {
    let input = include_str!("validate_connections/fixtures/connection-with-page-info.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-with-page-info.expected");
    test_fixture(transform_fixture, "connection-with-page-info.graphql", "validate_connections/fixtures/connection-with-page-info.expected", input, expected);
}

#[test]
fn connection_with_variables() {
    let input = include_str!("validate_connections/fixtures/connection-with-variables.graphql");
    let expected = include_str!("validate_connections/fixtures/connection-with-variables.expected");
    test_fixture(transform_fixture, "connection-with-variables.graphql", "validate_connections/fixtures/connection-with-variables.expected", input, expected);
}

#[test]
fn stream_connection_with_aliased_edges_invalid() {
    let input = include_str!("validate_connections/fixtures/stream-connection-with-aliased-edges.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/stream-connection-with-aliased-edges.invalid.expected");
    test_fixture(transform_fixture, "stream-connection-with-aliased-edges.invalid.graphql", "validate_connections/fixtures/stream-connection-with-aliased-edges.invalid.expected", input, expected);
}

#[test]
fn stream_connection_with_aliased_page_info_invalid() {
    let input = include_str!("validate_connections/fixtures/stream-connection-with-aliased-page-info.invalid.graphql");
    let expected = include_str!("validate_connections/fixtures/stream-connection-with-aliased-page-info.invalid.expected");
    test_fixture(transform_fixture, "stream-connection-with-aliased-page-info.invalid.graphql", "validate_connections/fixtures/stream-connection-with-aliased-page-info.invalid.expected", input, expected);
}