/*
 * 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<<7e199fca5115686b17339b3e81aeaf9d>>
 */

mod assignable_fragment_spread;

use assignable_fragment_spread::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn abstract_assignable_fragment_spread_on_concrete_type() {
    let input = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type.expected");
    test_fixture(transform_fixture, "abstract-assignable-fragment-spread-on-concrete-type.graphql", "assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type.expected", input, expected);
}

#[test]
fn abstract_assignable_fragment_spread_on_concrete_type_in_updatable_fragment() {
    let input = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type-in-updatable-fragment.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type-in-updatable-fragment.expected");
    test_fixture(transform_fixture, "abstract-assignable-fragment-spread-on-concrete-type-in-updatable-fragment.graphql", "assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-concrete-type-in-updatable-fragment.expected", input, expected);
}

#[test]
fn abstract_assignable_fragment_spread_on_different_abstract_type() {
    let input = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-different-abstract-type.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-different-abstract-type.expected");
    test_fixture(transform_fixture, "abstract-assignable-fragment-spread-on-different-abstract-type.graphql", "assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-different-abstract-type.expected", input, expected);
}

#[test]
fn abstract_assignable_fragment_spread_on_matching_abstract_type() {
    let input = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-matching-abstract-type.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-matching-abstract-type.expected");
    test_fixture(transform_fixture, "abstract-assignable-fragment-spread-on-matching-abstract-type.graphql", "assignable_fragment_spread/fixtures/abstract-assignable-fragment-spread-on-matching-abstract-type.expected", input, expected);
}

#[test]
fn assignable_fragment_spread_top_level_invalid() {
    let input = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-top-level.invalid.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-top-level.invalid.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-top-level.invalid.graphql", "assignable_fragment_spread/fixtures/assignable-fragment-spread-top-level.invalid.expected", input, expected);
}

#[test]
fn assignable_fragment_spread_with_directives_invalid() {
    let input = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-with-directives.invalid.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-with-directives.invalid.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-with-directives.invalid.graphql", "assignable_fragment_spread/fixtures/assignable-fragment-spread-with-directives.invalid.expected", input, expected);
}

#[test]
fn assignable_fragment_spread_within_inline_fragment() {
    let input = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-within-inline-fragment.graphql", "assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment.expected", input, expected);
}

#[test]
fn assignable_fragment_spread_within_inline_fragment_and_linked_field() {
    let input = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment-and-linked-field.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment-and-linked-field.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-within-inline-fragment-and-linked-field.graphql", "assignable_fragment_spread/fixtures/assignable-fragment-spread-within-inline-fragment-and-linked-field.expected", input, expected);
}

#[test]
fn assignable_fragment_spread_within_skipped_inline_fragment_invalid() {
    let input = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-skipped-inline-fragment.invalid.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/assignable-fragment-spread-within-skipped-inline-fragment.invalid.expected");
    test_fixture(transform_fixture, "assignable-fragment-spread-within-skipped-inline-fragment.invalid.graphql", "assignable_fragment_spread/fixtures/assignable-fragment-spread-within-skipped-inline-fragment.invalid.expected", input, expected);
}

#[test]
fn concrete_assignable_fragment_spread_on_abstract_type() {
    let input = include_str!("assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-abstract-type.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-abstract-type.expected");
    test_fixture(transform_fixture, "concrete-assignable-fragment-spread-on-abstract-type.graphql", "assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-abstract-type.expected", input, expected);
}

#[test]
fn concrete_assignable_fragment_spread_on_matching_concrete_type() {
    let input = include_str!("assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-matching-concrete-type.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-matching-concrete-type.expected");
    test_fixture(transform_fixture, "concrete-assignable-fragment-spread-on-matching-concrete-type.graphql", "assignable_fragment_spread/fixtures/concrete-assignable-fragment-spread-on-matching-concrete-type.expected", input, expected);
}

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

#[test]
fn skipped_assignable_fragment_spread_invalid() {
    let input = include_str!("assignable_fragment_spread/fixtures/skipped-assignable-fragment-spread.invalid.graphql");
    let expected = include_str!("assignable_fragment_spread/fixtures/skipped-assignable-fragment-spread.invalid.expected");
    test_fixture(transform_fixture, "skipped-assignable-fragment-spread.invalid.graphql", "assignable_fragment_spread/fixtures/skipped-assignable-fragment-spread.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<<854ac84b500428562e2f3baa3ad4d13b>>
 */

mod client_edges;

use client_edges::transform_fixture;
use fixture_tests::test_fixture;

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

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

#[test]
fn client_edge_inline_fragment_no_type_condition() {
    let input = include_str!("client_edges/fixtures/client-edge-inline-fragment-no-type-condition.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-inline-fragment-no-type-condition.expected");
    test_fixture(transform_fixture, "client-edge-inline-fragment-no-type-condition.graphql", "client_edges/fixtures/client-edge-inline-fragment-no-type-condition.expected", input, expected);
}

#[test]
fn client_edge_to_client_interface_invalid() {
    let input = include_str!("client_edges/fixtures/client-edge-to-client-interface.invalid.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-to-client-interface.invalid.expected");
    test_fixture(transform_fixture, "client-edge-to-client-interface.invalid.graphql", "client_edges/fixtures/client-edge-to-client-interface.invalid.expected", input, expected);
}

#[test]
fn client_edge_to_client_object() {
    let input = include_str!("client_edges/fixtures/client-edge-to-client-object.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-to-client-object.expected");
    test_fixture(transform_fixture, "client-edge-to-client-object.graphql", "client_edges/fixtures/client-edge-to-client-object.expected", input, expected);
}

#[test]
fn client_edge_to_client_union_invalid() {
    let input = include_str!("client_edges/fixtures/client-edge-to-client-union.invalid.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-to-client-union.invalid.expected");
    test_fixture(transform_fixture, "client-edge-to-client-union.invalid.graphql", "client_edges/fixtures/client-edge-to-client-union.invalid.expected", input, expected);
}

#[test]
fn client_edge_variables() {
    let input = include_str!("client_edges/fixtures/client-edge-variables.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-variables.expected");
    test_fixture(transform_fixture, "client-edge-variables.graphql", "client_edges/fixtures/client-edge-variables.expected", input, expected);
}

#[test]
fn client_edge_with_required() {
    let input = include_str!("client_edges/fixtures/client-edge-with-required.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-with-required.expected");
    test_fixture(transform_fixture, "client-edge-with-required.graphql", "client_edges/fixtures/client-edge-with-required.expected", input, expected);
}

#[test]
fn client_edge_within_non_client_edge() {
    let input = include_str!("client_edges/fixtures/client-edge-within-non-client-edge.graphql");
    let expected = include_str!("client_edges/fixtures/client-edge-within-non-client-edge.expected");
    test_fixture(transform_fixture, "client-edge-within-non-client-edge.graphql", "client_edges/fixtures/client-edge-within-non-client-edge.expected", input, expected);
}

#[test]
fn nested_client_edges() {
    let input = include_str!("client_edges/fixtures/nested-client-edges.graphql");
    let expected = include_str!("client_edges/fixtures/nested-client-edges.expected");
    test_fixture(transform_fixture, "nested-client-edges.graphql", "client_edges/fixtures/nested-client-edges.expected", input, expected);
}

#[test]
fn nested_client_edges_with_variables() {
    let input = include_str!("client_edges/fixtures/nested-client-edges-with-variables.graphql");
    let expected = include_str!("client_edges/fixtures/nested-client-edges-with-variables.expected");
    test_fixture(transform_fixture, "nested-client-edges-with-variables.graphql", "client_edges/fixtures/nested-client-edges-with-variables.expected", input, expected);
}

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

#[test]
fn nested_path_with_alias() {
    let input = include_str!("client_edges/fixtures/nested-path-with-alias.graphql");
    let expected = include_str!("client_edges/fixtures/nested-path-with-alias.expected");
    test_fixture(transform_fixture, "nested-path-with-alias.graphql", "client_edges/fixtures/nested-path-with-alias.expected", input, expected);
}

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

#[test]
fn unexpected_waterfall_invalid() {
    let input = include_str!("client_edges/fixtures/unexpected-waterfall.invalid.graphql");
    let expected = include_str!("client_edges/fixtures/unexpected-waterfall.invalid.expected");
    test_fixture(transform_fixture, "unexpected-waterfall.invalid.graphql", "client_edges/fixtures/unexpected-waterfall.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<<e5c24b5453bde4b099eb2517e15d853f>>
 */

mod client_extensions_abstract_types;

use client_extensions_abstract_types::transform_fixture;
use fixture_tests::test_fixture;

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

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

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

#[test]
fn inline_fragment_on_client_interface() {
    let input = include_str!("client_extensions_abstract_types/fixtures/inline_fragment_on_client_interface.graphql");
    let expected = include_str!("client_extensions_abstract_types/fixtures/inline_fragment_on_client_interface.expected");
    test_fixture(transform_fixture, "inline_fragment_on_client_interface.graphql", "client_extensions_abstract_types/fixtures/inline_fragment_on_client_interface.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<<8e76da20110296ac303bd405d2001557>>
 */

mod client_extensions;

use client_extensions::transform_fixture;
use fixture_tests::test_fixture;

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

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

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

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

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

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

#[test]
fn sibling_client_selections() {
    let input = include_str!("client_extensions/fixtures/sibling-client-selections.graphql");
    let expected = include_str!("client_extensions/fixtures/sibling-client-selections.expected");
    test_fixture(transform_fixture, "sibling-client-selections.graphql", "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<<73cfaa2e0393cd88236a48e688f50dea>>
 */

mod declarative_connection;

use declarative_connection::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn append_edge_unspported_invalid() {
    let input = include_str!("declarative_connection/fixtures/append-edge-unspported.invalid.graphql");
    let expected = include_str!("declarative_connection/fixtures/append-edge-unspported.invalid.expected");
    test_fixture(transform_fixture, "append-edge-unspported.invalid.graphql", "declarative_connection/fixtures/append-edge-unspported.invalid.expected", input, expected);
}

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

#[test]
fn append_node_edge_literal() {
    let input = include_str!("declarative_connection/fixtures/append-node-edge-literal.graphql");
    let expected = include_str!("declarative_connection/fixtures/append-node-edge-literal.expected");
    test_fixture(transform_fixture, "append-node-edge-literal.graphql", "declarative_connection/fixtures/append-node-edge-literal.expected", input, expected);
}

#[test]
fn append_node_unsupported_invalid() {
    let input = include_str!("declarative_connection/fixtures/append-node-unsupported.invalid.graphql");
    let expected = include_str!("declarative_connection/fixtures/append-node-unsupported.invalid.expected");
    test_fixture(transform_fixture, "append-node-unsupported.invalid.graphql", "declarative_connection/fixtures/append-node-unsupported.invalid.expected", input, expected);
}

#[test]
fn delete_edge_from_connection() {
    let input = include_str!("declarative_connection/fixtures/delete-edge-from-connection.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-edge-from-connection.expected");
    test_fixture(transform_fixture, "delete-edge-from-connection.graphql", "declarative_connection/fixtures/delete-edge-from-connection.expected", input, expected);
}

#[test]
fn delete_edge_from_connection_on_unsupported_type_invalid() {
    let input = include_str!("declarative_connection/fixtures/delete-edge-from-connection-on-unsupported-type.invalid.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-edge-from-connection-on-unsupported-type.invalid.expected");
    test_fixture(transform_fixture, "delete-edge-from-connection-on-unsupported-type.invalid.graphql", "declarative_connection/fixtures/delete-edge-from-connection-on-unsupported-type.invalid.expected", input, expected);
}

#[test]
fn delete_edge_from_connection_plural() {
    let input = include_str!("declarative_connection/fixtures/delete-edge-from-connection-plural.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-edge-from-connection-plural.expected");
    test_fixture(transform_fixture, "delete-edge-from-connection-plural.graphql", "declarative_connection/fixtures/delete-edge-from-connection-plural.expected", input, expected);
}

#[test]
fn delete_from_store() {
    let input = include_str!("declarative_connection/fixtures/delete-from-store.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-from-store.expected");
    test_fixture(transform_fixture, "delete-from-store.graphql", "declarative_connection/fixtures/delete-from-store.expected", input, expected);
}

#[test]
fn delete_from_store_plural() {
    let input = include_str!("declarative_connection/fixtures/delete-from-store-plural.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-from-store-plural.expected");
    test_fixture(transform_fixture, "delete-from-store-plural.graphql", "declarative_connection/fixtures/delete-from-store-plural.expected", input, expected);
}

#[test]
fn delete_on_unspported_type_invalid() {
    let input = include_str!("declarative_connection/fixtures/delete-on-unspported-type.invalid.graphql");
    let expected = include_str!("declarative_connection/fixtures/delete-on-unspported-type.invalid.expected");
    test_fixture(transform_fixture, "delete-on-unspported-type.invalid.graphql", "declarative_connection/fixtures/delete-on-unspported-type.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<<c389b836270f13295c42ac1ed3dc1bb3>>
 */

mod defer_stream;

use defer_stream::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn fragment_with_defer_arguments() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-arguments.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-arguments.expected");
    test_fixture(transform_fixture, "fragment-with-defer-arguments.graphql", "defer_stream/fixtures/fragment-with-defer-arguments.expected", input, expected);
}

#[test]
fn fragment_with_defer_default_label() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-default-label.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-default-label.expected");
    test_fixture(transform_fixture, "fragment-with-defer-default-label.graphql", "defer_stream/fixtures/fragment-with-defer-default-label.expected", input, expected);
}

#[test]
fn fragment_with_defer_duplicate_label_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-duplicate-label.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-duplicate-label.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-defer-duplicate-label.invalid.graphql", "defer_stream/fixtures/fragment-with-defer-duplicate-label.invalid.expected", input, expected);
}

#[test]
fn fragment_with_defer_if_arg() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-if-arg.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-if-arg.expected");
    test_fixture(transform_fixture, "fragment-with-defer-if-arg.graphql", "defer_stream/fixtures/fragment-with-defer-if-arg.expected", input, expected);
}

#[test]
fn fragment_with_defer_if_false() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-if-false.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-if-false.expected");
    test_fixture(transform_fixture, "fragment-with-defer-if-false.graphql", "defer_stream/fixtures/fragment-with-defer-if-false.expected", input, expected);
}

#[test]
fn fragment_with_defer_statically_disabled() {
    let input = include_str!("defer_stream/fixtures/fragment-with-defer-statically-disabled.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-defer-statically-disabled.expected");
    test_fixture(transform_fixture, "fragment-with-defer-statically-disabled.graphql", "defer_stream/fixtures/fragment-with-defer-statically-disabled.expected", input, expected);
}

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

#[test]
fn fragment_with_stream_default_label() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-default-label.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-default-label.expected");
    test_fixture(transform_fixture, "fragment-with-stream-default-label.graphql", "defer_stream/fixtures/fragment-with-stream-default-label.expected", input, expected);
}

#[test]
fn fragment_with_stream_duplicate_label_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-duplicate-label.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-duplicate-label.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-stream-duplicate-label.invalid.graphql", "defer_stream/fixtures/fragment-with-stream-duplicate-label.invalid.expected", input, expected);
}

#[test]
fn fragment_with_stream_if_arg() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-if-arg.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-if-arg.expected");
    test_fixture(transform_fixture, "fragment-with-stream-if-arg.graphql", "defer_stream/fixtures/fragment-with-stream-if-arg.expected", input, expected);
}

#[test]
fn fragment_with_stream_initial_count_arg() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-initial-count-arg.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-initial-count-arg.expected");
    test_fixture(transform_fixture, "fragment-with-stream-initial-count-arg.graphql", "defer_stream/fixtures/fragment-with-stream-initial-count-arg.expected", input, expected);
}

#[test]
fn fragment_with_stream_missing_initial_count_arg_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-missing-initial-count-arg.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-missing-initial-count-arg.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-stream-missing-initial-count-arg.invalid.graphql", "defer_stream/fixtures/fragment-with-stream-missing-initial-count-arg.invalid.expected", input, expected);
}

#[test]
fn fragment_with_stream_on_scalar_field_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-on-scalar-field.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-on-scalar-field.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-stream-on-scalar-field.invalid.graphql", "defer_stream/fixtures/fragment-with-stream-on-scalar-field.invalid.expected", input, expected);
}

#[test]
fn fragment_with_stream_statically_disabled() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-statically-disabled.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-statically-disabled.expected");
    test_fixture(transform_fixture, "fragment-with-stream-statically-disabled.graphql", "defer_stream/fixtures/fragment-with-stream-statically-disabled.expected", input, expected);
}

#[test]
fn fragment_with_stream_use_customized_batch_arg() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-use_customized_batch-arg.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-use_customized_batch-arg.expected");
    test_fixture(transform_fixture, "fragment-with-stream-use_customized_batch-arg.graphql", "defer_stream/fixtures/fragment-with-stream-use_customized_batch-arg.expected", input, expected);
}

#[test]
fn fragment_with_stream_variable_label_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-stream-variable-label.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-stream-variable-label.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-stream-variable-label.invalid.graphql", "defer_stream/fixtures/fragment-with-stream-variable-label.invalid.expected", input, expected);
}

#[test]
fn fragment_with_variable_label_invalid() {
    let input = include_str!("defer_stream/fixtures/fragment-with-variable-label.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/fragment-with-variable-label.invalid.expected");
    test_fixture(transform_fixture, "fragment-with-variable-label.invalid.graphql", "defer_stream/fixtures/fragment-with-variable-label.invalid.expected", input, expected);
}

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

#[test]
fn query_with_defer() {
    let input = include_str!("defer_stream/fixtures/query-with-defer.graphql");
    let expected = include_str!("defer_stream/fixtures/query-with-defer.expected");
    test_fixture(transform_fixture, "query-with-defer.graphql", "defer_stream/fixtures/query-with-defer.expected", input, expected);
}

#[test]
fn query_with_stream() {
    let input = include_str!("defer_stream/fixtures/query-with-stream.graphql");
    let expected = include_str!("defer_stream/fixtures/query-with-stream.expected");
    test_fixture(transform_fixture, "query-with-stream.graphql", "defer_stream/fixtures/query-with-stream.expected", input, expected);
}

#[test]
fn stream_invalid() {
    let input = include_str!("defer_stream/fixtures/stream.invalid.graphql");
    let expected = include_str!("defer_stream/fixtures/stream.invalid.expected");
    test_fixture(transform_fixture, "stream.invalid.graphql", "defer_stream/fixtures/stream.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<<f866920b35bb2c51bef0e641909def0f>>
 */

mod disallow_non_node_id_fields;

use disallow_non_node_id_fields::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn disallowed_definitions_invalid() {
    let input = include_str!("disallow_non_node_id_fields/fixtures/disallowed-definitions.invalid.graphql");
    let expected = include_str!("disallow_non_node_id_fields/fixtures/disallowed-definitions.invalid.expected");
    test_fixture(transform_fixture, "disallowed-definitions.invalid.graphql", "disallow_non_node_id_fields/fixtures/disallowed-definitions.invalid.expected", input, expected);
}

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

#[test]
fn invalid_id_selection_allowed() {
    let input = include_str!("disallow_non_node_id_fields/fixtures/invalid-id-selection-allowed.graphql");
    let expected = include_str!("disallow_non_node_id_fields/fixtures/invalid-id-selection-allowed.expected");
    test_fixture(transform_fixture, "invalid-id-selection-allowed.graphql", "disallow_non_node_id_fields/fixtures/invalid-id-selection-allowed.expected", input, expected);
}

#[test]
fn invalid_id_selection_disallowed_invalid() {
    let input = include_str!("disallow_non_node_id_fields/fixtures/invalid-id-selection-disallowed.invalid.graphql");
    let expected = include_str!("disallow_non_node_id_fields/fixtures/invalid-id-selection-disallowed.invalid.expected");
    test_fixture(transform_fixture, "invalid-id-selection-disallowed.invalid.graphql", "disallow_non_node_id_fields/fixtures/invalid-id-selection-disallowed.invalid.expected", input, expected);
}

#[test]
fn valid_id_selection() {
    let input = include_str!("disallow_non_node_id_fields/fixtures/valid-id-selection.graphql");
    let expected = include_str!("disallow_non_node_id_fields/fixtures/valid-id-selection.expected");
    test_fixture(transform_fixture, "valid-id-selection.graphql", "disallow_non_node_id_fields/fixtures/valid-id-selection.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<<8184d04f25bd777e8ff56df2e2baff89>>
 */

mod disallow_reserved_aliases;

use disallow_reserved_aliases::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn id_alias_with_errors_invalid() {
    let input = include_str!("disallow_reserved_aliases/fixtures/id-alias-with-errors.invalid.graphql");
    let expected = include_str!("disallow_reserved_aliases/fixtures/id-alias-with-errors.invalid.expected");
    test_fixture(transform_fixture, "id-alias-with-errors.invalid.graphql", "disallow_reserved_aliases/fixtures/id-alias-with-errors.invalid.expected", input, expected);
}

#[test]
fn relay_id_alias_with_errors_invalid() {
    let input = include_str!("disallow_reserved_aliases/fixtures/relay_id-alias-with-errors.invalid.graphql");
    let expected = include_str!("disallow_reserved_aliases/fixtures/relay_id-alias-with-errors.invalid.expected");
    test_fixture(transform_fixture, "relay_id-alias-with-errors.invalid.graphql", "disallow_reserved_aliases/fixtures/relay_id-alias-with-errors.invalid.expected", input, expected);
}

#[test]
fn typename_alias_with_errors_invalid() {
    let input = include_str!("disallow_reserved_aliases/fixtures/typename-alias-with-errors.invalid.graphql");
    let expected = include_str!("disallow_reserved_aliases/fixtures/typename-alias-with-errors.invalid.expected");
    test_fixture(transform_fixture, "typename-alias-with-errors.invalid.graphql", "disallow_reserved_aliases/fixtures/typename-alias-with-errors.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<<39f0a34f3acf5f9d49cd579af5dbc8f8>>
 */

mod disallow_typename_on_root;

use disallow_typename_on_root::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn typename_on_mutation_invalid() {
    let input = include_str!("disallow_typename_on_root/fixtures/typename-on-mutation.invalid.graphql");
    let expected = include_str!("disallow_typename_on_root/fixtures/typename-on-mutation.invalid.expected");
    test_fixture(transform_fixture, "typename-on-mutation.invalid.graphql", "disallow_typename_on_root/fixtures/typename-on-mutation.invalid.expected", input, expected);
}

#[test]
fn typename_on_query_invalid() {
    let input = include_str!("disallow_typename_on_root/fixtures/typename-on-query.invalid.graphql");
    let expected = include_str!("disallow_typename_on_root/fixtures/typename-on-query.invalid.expected");
    test_fixture(transform_fixture, "typename-on-query.invalid.graphql", "disallow_typename_on_root/fixtures/typename-on-query.invalid.expected", input, expected);
}

#[test]
fn valid() {
    let input = include_str!("disallow_typename_on_root/fixtures/valid.graphql");
    let expected = include_str!("disallow_typename_on_root/fixtures/valid.expected");
    test_fixture(transform_fixture, "valid.graphql", "disallow_typename_on_root/fixtures/valid.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<<fe81a00272bc1a72fb7ed893652fd0b6>>
 */

mod flatten;

use flatten::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn anonymous_inline_fragment_with_directives() {
    let input = include_str!("flatten/fixtures/anonymous-inline-fragment-with-directives.graphql");
    let expected = include_str!("flatten/fixtures/anonymous-inline-fragment-with-directives.expected");
    test_fixture(transform_fixture, "anonymous-inline-fragment-with-directives.graphql", "flatten/fixtures/anonymous-inline-fragment-with-directives.expected", input, expected);
}

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

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

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

#[test]
fn flattens_inline_inside_condition() {
    let input = include_str!("flatten/fixtures/flattens-inline-inside-condition.graphql");
    let expected = include_str!("flatten/fixtures/flattens-inline-inside-condition.expected");
    test_fixture(transform_fixture, "flattens-inline-inside-condition.graphql", "flatten/fixtures/flattens-inline-inside-condition.expected", input, expected);
}

#[test]
fn flattens_inside_plural() {
    let input = include_str!("flatten/fixtures/flattens-inside-plural.graphql");
    let expected = include_str!("flatten/fixtures/flattens-inside-plural.expected");
    test_fixture(transform_fixture, "flattens-inside-plural.graphql", "flatten/fixtures/flattens-inside-plural.expected", input, expected);
}

#[test]
fn flattens_matching_fragment_types() {
    let input = include_str!("flatten/fixtures/flattens-matching-fragment-types.graphql");
    let expected = include_str!("flatten/fixtures/flattens-matching-fragment-types.expected");
    test_fixture(transform_fixture, "flattens-matching-fragment-types.graphql", "flatten/fixtures/flattens-matching-fragment-types.expected", input, expected);
}

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

#[test]
fn inline_fragment_with_directives_text() {
    let input = include_str!("flatten/fixtures/inline-fragment-with-directives-text.graphql");
    let expected = include_str!("flatten/fixtures/inline-fragment-with-directives-text.expected");
    test_fixture(transform_fixture, "inline-fragment-with-directives-text.graphql", "flatten/fixtures/inline-fragment-with-directives-text.expected", input, expected);
}

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

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

#[test]
fn match_field_overlap() {
    let input = include_str!("flatten/fixtures/match-field-overlap.graphql");
    let expected = include_str!("flatten/fixtures/match-field-overlap.expected");
    test_fixture(transform_fixture, "match-field-overlap.graphql", "flatten/fixtures/match-field-overlap.expected", input, expected);
}

#[test]
fn scalar_handle_field() {
    let input = include_str!("flatten/fixtures/scalar-handle-field.graphql");
    let expected = include_str!("flatten/fixtures/scalar-handle-field.expected");
    test_fixture(transform_fixture, "scalar-handle-field.graphql", "flatten/fixtures/scalar-handle-field.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<<181f8435539d1237e4b620d14a79c100>>
 */

mod fragment_alias_directive;

use fragment_alias_directive::transform_fixture;
use fixture_tests::test_fixture;

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

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

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

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

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

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

#[test]
fn default_alias_on_inline_fragment_without_type_invalid() {
    let input = include_str!("fragment_alias_directive/fixtures/default_alias_on_inline_fragment_without_type.invalid.graphql");
    let expected = include_str!("fragment_alias_directive/fixtures/default_alias_on_inline_fragment_without_type.invalid.expected");
    test_fixture(transform_fixture, "default_alias_on_inline_fragment_without_type.invalid.graphql", "fragment_alias_directive/fixtures/default_alias_on_inline_fragment_without_type.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<<378ad574a05b62abf204013f996c8c8f>>
 */

mod generate_data_driven_dependency_metadata;

use generate_data_driven_dependency_metadata::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn match_on_child_of_plural() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/match-on-child-of-plural.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/match-on-child-of-plural.expected");
    test_fixture(transform_fixture, "match-on-child-of-plural.graphql", "generate_data_driven_dependency_metadata/fixtures/match-on-child-of-plural.expected", input, expected);
}

#[test]
fn match_with_extra_args() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/match-with-extra-args.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/match-with-extra-args.expected");
    test_fixture(transform_fixture, "match-with-extra-args.graphql", "generate_data_driven_dependency_metadata/fixtures/match-with-extra-args.expected", input, expected);
}

#[test]
fn module_without_match() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/module-without-match.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/module-without-match.expected");
    test_fixture(transform_fixture, "module-without-match.graphql", "generate_data_driven_dependency_metadata/fixtures/module-without-match.expected", input, expected);
}

#[test]
fn query_with_direct_and_transitive_module_dep() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-direct-and-transitive-module-dep.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-direct-and-transitive-module-dep.expected");
    test_fixture(transform_fixture, "query-with-direct-and-transitive-module-dep.graphql", "generate_data_driven_dependency_metadata/fixtures/query-with-direct-and-transitive-module-dep.expected", input, expected);
}

#[test]
fn query_with_direct_module_dep() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-direct-module-dep.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-direct-module-dep.expected");
    test_fixture(transform_fixture, "query-with-direct-module-dep.graphql", "generate_data_driven_dependency_metadata/fixtures/query-with-direct-module-dep.expected", input, expected);
}

#[test]
fn query_with_transitive_module_dep() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-transitive-module-dep.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/query-with-transitive-module-dep.expected");
    test_fixture(transform_fixture, "query-with-transitive-module-dep.graphql", "generate_data_driven_dependency_metadata/fixtures/query-with-transitive-module-dep.expected", input, expected);
}

#[test]
fn relay_match_on_interface() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-interface.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-interface.expected");
    test_fixture(transform_fixture, "relay-match-on-interface.graphql", "generate_data_driven_dependency_metadata/fixtures/relay-match-on-interface.expected", input, expected);
}

#[test]
fn relay_match_on_union() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-union.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-union.expected");
    test_fixture(transform_fixture, "relay-match-on-union.graphql", "generate_data_driven_dependency_metadata/fixtures/relay-match-on-union.expected", input, expected);
}

#[test]
fn relay_match_on_union_plural() {
    let input = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-union-plural.graphql");
    let expected = include_str!("generate_data_driven_dependency_metadata/fixtures/relay-match-on-union-plural.expected");
    test_fixture(transform_fixture, "relay-match-on-union-plural.graphql", "generate_data_driven_dependency_metadata/fixtures/relay-match-on-union-plural.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<<63e612da0245a0cd1493300c56063de9>>
 */

mod generate_id_field;

use generate_id_field::transform_fixture;
use fixture_tests::test_fixture;

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

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

#[test]
fn non_node_union() {
    let input = include_str!("generate_id_field/fixtures/non-node-union.graphql");
    let expected = include_str!("generate_id_field/fixtures/non-node-union.expected");
    test_fixture(transform_fixture, "non-node-union.graphql", "generate_id_field/fixtures/non-node-union.expected", input, expected);
}

#[test]
fn query_with_fragment_variables() {
    let input = include_str!("generate_id_field/fixtures/query-with-fragment-variables.graphql");
    let expected = include_str!("generate_id_field/fixtures/query-with-fragment-variables.expected");
    test_fixture(transform_fixture, "query-with-fragment-variables.graphql", "generate_id_field/fixtures/query-with-fragment-variables.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<<9da1c41afc4ceb2bf703a95c2c85fc79>>
 */

mod generate_live_query_metadata;

use generate_live_query_metadata::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn live_by_polling_interval() {
    let input = include_str!("generate_live_query_metadata/fixtures/live_by_polling_interval.graphql");
    let expected = include_str!("generate_live_query_metadata/fixtures/live_by_polling_interval.expected");
    test_fixture(transform_fixture, "live_by_polling_interval.graphql", "generate_live_query_metadata/fixtures/live_by_polling_interval.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<<905ebd71110679c262b41e411ebc3fe4>>
 */

mod generate_relay_resolvers_operations_for_nested_objects;

use generate_relay_resolvers_operations_for_nested_objects::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn output_type_client_type() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-client-type.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-client-type.expected");
    test_fixture(transform_fixture, "output-type-client-type.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-client-type.expected", input, expected);
}

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

#[test]
fn output_type_scalar() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-scalar.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-scalar.expected");
    test_fixture(transform_fixture, "output-type-scalar.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-scalar.expected", input, expected);
}

#[test]
fn output_type_with_arguments() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-arguments.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-arguments.expected");
    test_fixture(transform_fixture, "output-type-with-arguments.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-arguments.expected", input, expected);
}

#[test]
fn output_type_with_client_interface() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface.expected");
    test_fixture(transform_fixture, "output-type-with-client-interface.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface.expected", input, expected);
}

#[test]
fn output_type_with_client_interface_and_object_recursion_invalid() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-and-object-recursion.invalid.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-and-object-recursion.invalid.expected");
    test_fixture(transform_fixture, "output-type-with-client-interface-and-object-recursion.invalid.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-and-object-recursion.invalid.expected", input, expected);
}

#[test]
fn output_type_with_client_interface_recursion_invalid() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-recursion.invalid.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-recursion.invalid.expected");
    test_fixture(transform_fixture, "output-type-with-client-interface-recursion.invalid.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-client-interface-recursion.invalid.expected", input, expected);
}

#[test]
fn output_type_with_id() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-id.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-id.expected");
    test_fixture(transform_fixture, "output-type-with-id.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-id.expected", input, expected);
}

#[test]
fn output_type_with_interface_recursion_but_lying_client_type() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-interface-recursion-but-lying-client-type.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-interface-recursion-but-lying-client-type.expected");
    test_fixture(transform_fixture, "output-type-with-interface-recursion-but-lying-client-type.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-interface-recursion-but-lying-client-type.expected", input, expected);
}

#[test]
fn output_type_with_nested_recursion() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-recursion.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-recursion.expected");
    test_fixture(transform_fixture, "output-type-with-nested-recursion.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-recursion.expected", input, expected);
}

#[test]
fn output_type_with_nested_server_object() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-server-object.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-server-object.expected");
    test_fixture(transform_fixture, "output-type-with-nested-server-object.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-nested-server-object.expected", input, expected);
}

#[test]
fn output_type_with_recursion() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-recursion.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-recursion.expected");
    test_fixture(transform_fixture, "output-type-with-recursion.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-recursion.expected", input, expected);
}

#[test]
fn output_type_with_relay_resolver_fields() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-relay-resolver-fields.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-relay-resolver-fields.expected");
    test_fixture(transform_fixture, "output-type-with-relay-resolver-fields.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-relay-resolver-fields.expected", input, expected);
}

#[test]
fn output_type_with_server_interface_invalid() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-interface.invalid.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-interface.invalid.expected");
    test_fixture(transform_fixture, "output-type-with-server-interface.invalid.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-interface.invalid.expected", input, expected);
}

#[test]
fn output_type_with_server_object() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-object.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-object.expected");
    test_fixture(transform_fixture, "output-type-with-server-object.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-server-object.expected", input, expected);
}

#[test]
fn output_type_with_type_with_id() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-type-with-id.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-type-with-id.expected");
    test_fixture(transform_fixture, "output-type-with-type-with-id.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-type-with-id.expected", input, expected);
}

#[test]
fn output_type_with_unimplemented_interface_invalid() {
    let input = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-unimplemented-interface.invalid.graphql");
    let expected = include_str!("generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-unimplemented-interface.invalid.expected");
    test_fixture(transform_fixture, "output-type-with-unimplemented-interface.invalid.graphql", "generate_relay_resolvers_operations_for_nested_objects/fixtures/output-type-with-unimplemented-interface.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<<3cb2d87b70b16df6d256ff07d9daa83d>>
 */

mod generate_typename;

use generate_typename::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn type_name_does_not_exist() {
    let input = include_str!("generate_typename/fixtures/type-name-does-not-exist.graphql");
    let expected = include_str!("generate_typename/fixtures/type-name-does-not-exist.expected");
    test_fixture(transform_fixture, "type-name-does-not-exist.graphql", "generate_typename/fixtures/type-name-does-not-exist.expected", input, expected);
}

#[test]
fn type_name_exists() {
    let input = include_str!("generate_typename/fixtures/type-name-exists.graphql");
    let expected = include_str!("generate_typename/fixtures/type-name-exists.expected");
    test_fixture(transform_fixture, "type-name-exists.graphql", "generate_typename/fixtures/type-name-exists.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<<0b5686d10624fd1700d69be68ba3f437>>
 */

mod inline_data_fragment;

use inline_data_fragment::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn variables() {
    let input = include_str!("inline_data_fragment/fixtures/variables.graphql");
    let expected = include_str!("inline_data_fragment/fixtures/variables.expected");
    test_fixture(transform_fixture, "variables.graphql", "inline_data_fragment/fixtures/variables.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<<b479d421b643f2383902f35936c21430>>
 */

mod inline_fragments;

use inline_fragments::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn inlines_nested_fragments() {
    let input = include_str!("inline_fragments/fixtures/inlines-nested-fragments.graphql");
    let expected = include_str!("inline_fragments/fixtures/inlines-nested-fragments.expected");
    test_fixture(transform_fixture, "inlines-nested-fragments.graphql", "inline_fragments/fixtures/inlines-nested-fragments.expected", input, expected);
}

#[test]
fn inlines_with_directive() {
    let input = include_str!("inline_fragments/fixtures/inlines-with-directive.graphql");
    let expected = include_str!("inline_fragments/fixtures/inlines-with-directive.expected");
    test_fixture(transform_fixture, "inlines-with-directive.graphql", "inline_fragments/fixtures/inlines-with-directive.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<<06cfcd9a6d5345cf8fba25d3382362fa>>
 */

mod mask;

use mask::transform_fixture;
use fixture_tests::test_fixture;

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

#[test]
fn relay_mask_transform() {
    let input = include_str!("mask/fixtures/relay-mask-transform.graphql");
    let expected = include_str!("mask/fixtures/relay-mask-transform.expected");
    test_fixture(transform_fixture, "relay-mask-transform.graphql", "mask/fixtures/relay-mask-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<<3f821e14128e35b76bc9d17c3ec8e96f>>
 */

mod match_transform_local;

use match_transform_local::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn module_on_field_without_js() {
    let input = include_str!("match_transform_local/fixtures/module-on-field-without-js.graphql");
    let expected = include_str!("match_transform_local/fixtures/module-on-field-without-js.expected");
    test_fixture(transform_fixture, "module-on-field-without-js.graphql", "match_transform_local/fixtures/module-on-field-without-js.expected", input, expected);
}

#[test]
fn module_without_match() {
    let input = include_str!("match_transform_local/fixtures/module-without-match.graphql");
    let expected = include_str!("match_transform_local/fixtures/module-without-match.expected");
    test_fixture(transform_fixture, "module-without-match.graphql", "match_transform_local/fixtures/module-without-match.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<<d9c1dc1b6ad85ebcbf422614fd709d3a>>
 */

mod match_transform;

use match_transform::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn direct_js_field_invalid() {
    let input = include_str!("match_transform/fixtures/direct-js-field.invalid.graphql");
    let expected = include_str!("match_transform/fixtures/direct-js-field.invalid.expected");
    test_fixture(transform_fixture, "direct-js-field.invalid.graphql", "match_transform/fixtures/direct-js-field.invalid.expected", input, expected);
}

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

#[test]
fn invalid_no_matches() {
    let input = include_str!("match_transform/fixtures/invalid-no-matches.graphql");
    let expected = include_str!("match_transform/fixtures/invalid-no-matches.expected");
    test_fixture(transform_fixture, "invalid-no-matches.graphql", "match_transform/fixtures/invalid-no-matches.expected", input, expected);
}

#[test]
fn invalid_non_empty_selections() {
    let input = include_str!("match_transform/fixtures/invalid-non-empty-selections.graphql");
    let expected = include_str!("match_transform/fixtures/invalid-non-empty-selections.expected");
    test_fixture(transform_fixture, "invalid-non-empty-selections.graphql", "match_transform/fixtures/invalid-non-empty-selections.expected", input, expected);
}

#[test]
fn match_on_child_of_plural() {
    let input = include_str!("match_transform/fixtures/match-on-child-of-plural.graphql");
    let expected = include_str!("match_transform/fixtures/match-on-child-of-plural.expected");
    test_fixture(transform_fixture, "match-on-child-of-plural.graphql", "match_transform/fixtures/match-on-child-of-plural.expected", input, expected);
}

#[test]
fn match_with_explicit_support_arg_invalid() {
    let input = include_str!("match_transform/fixtures/match-with-explicit-support-arg.invalid.graphql");
    let expected = include_str!("match_transform/fixtures/match-with-explicit-support-arg.invalid.expected");
    test_fixture(transform_fixture, "match-with-explicit-support-arg.invalid.graphql", "match_transform/fixtures/match-with-explicit-support-arg.invalid.expected", input, expected);
}

#[test]
fn match_with_extra_args() {
    let input = include_str!("match_transform/fixtures/match-with-extra-args.graphql");
    let expected = include_str!("match_transform/fixtures/match-with-extra-args.expected");
    test_fixture(transform_fixture, "match-with-extra-args.graphql", "match_transform/fixtures/match-with-extra-args.expected", input, expected);
}

#[test]
fn module_on_inline_data_invalid() {
    let input = include_str!("match_transform/fixtures/module-on-inline-data.invalid.graphql");
    let expected = include_str!("match_transform/fixtures/module-on-inline-data.invalid.expected");
    test_fixture(transform_fixture, "module-on-inline-data.invalid.graphql", "match_transform/fixtures/module-on-inline-data.invalid.expected", input, expected);
}

#[test]
fn module_with_other_directives_invalid() {
    let input = include_str!("match_transform/fixtures/module-with-other-directives.invalid.graphql");
    let expected = include_str!("match_transform/fixtures/module-with-other-directives.invalid.expected");
    test_fixture(transform_fixture, "module-with-other-directives.invalid.graphql", "match_transform/fixtures/module-with-other-directives.invalid.expected", input, expected);
}

#[test]
fn module_without_match() {
    let input = include_str!("match_transform/fixtures/module-without-match.graphql");
    let expected = include_str!("match_transform/fixtures/module-without-match.expected");
    test_fixture(transform_fixture, "module-without-match.graphql", "match_transform/fixtures/module-without-match.expected", input, expected);
}

#[test]
fn no_server_supported_arg_invalid() {
    let input = include_str!("match_transform/fixtures/no-server-supported-arg.invalid.graphql");
    let expected = include_str!("match_transform/fixtures/no-server-supported-arg.invalid.expected");
    test_fixture(transform_fixture, "no-server-supported-arg.invalid.graphql", "match_transform/fixtures/no-server-supported-arg.invalid.expected", input, expected);
}

#[test]
fn relay_match_on_interface() {
    let input = include_str!("match_transform/fixtures/relay-match-on-interface.graphql");
    let expected = include_str!("match_transform/fixtures/relay-match-on-interface.expected");
    test_fixture(transform_fixture, "relay-match-on-interface.graphql", "match_transform/fixtures/relay-match-on-interface.expected", input, expected);
}

#[test]
fn relay_match_on_union() {
    let input = include_str!("match_transform/fixtures/relay-match-on-union.graphql");
    let expected = include_str!("match_transform/fixtures/relay-match-on-union.expected");
    test_fixture(transform_fixture, "relay-match-on-union.graphql", "match_transform/fixtures/relay-match-on-union.expected", input, expected);
}

#[test]
fn relay_match_on_union_plural() {
    let input = include_str!("match_transform/fixtures/relay-match-on-union-plural.graphql");
    let expected = include_str!("match_transform/fixtures/relay-match-on-union-plural.expected");
    test_fixture(transform_fixture, "relay-match-on-union-plural.graphql", "match_transform/fixtures/relay-match-on-union-plural.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.
 */

use common::SourceLocationKey;
use graphql_ir::build;
use graphql_ir::node_identifier::NodeIdentifier;
use graphql_ir::ExecutableDefinition;
use graphql_ir::Selection;
use graphql_syntax::parse_executable;
use relay_test_schema::TEST_SCHEMA;
use relay_transforms::RelayLocationAgnosticBehavior;

fn get_selection(def: &ExecutableDefinition) -> &Selection {
    if let ExecutableDefinition::Fragment(frag) = def {
        &frag.selections[0]
    } else {
        panic!("No selection found in: {:#?}", &def);
    }
}

fn are_selections_equal(graphql: &str) -> bool {
    let source_location = SourceLocationKey::standalone("test");
    let ast = parse_executable(graphql, source_location).unwrap();
    let ir = build(&TEST_SCHEMA, &ast.definitions).unwrap();
    let left = NodeIdentifier::from_selection(
        &TEST_SCHEMA,
        get_selection(&ir[0]),
        RelayLocationAgnosticBehavior,
    );
    let right = NodeIdentifier::from_selection(
        &TEST_SCHEMA,
        get_selection(&ir[1]),
        RelayLocationAgnosticBehavior,
    );
    left == right
}

#[test]
fn test_fields() {
    assert!(are_selections_equal(
        r#"
                fragment Left on User {
                    name @customDirective(level: 1)
                }
                fragment Right on User {
                    name @customDirective(level: 1)
                }
            "#
    ));

    assert!(!are_selections_equal(
        r#"
                fragment Left on User {
                    name @customDirective(level: 1)
                }
                fragment Right on User {
                    name @customDirective(level: 2)
                }
            "#
    ));

    assert!(are_selections_equal(
        // When there is an alias, we only compare the alias instead of the original name
        r#"
                fragment Left on User {
                    name: username @customDirective(level: 1)
                }
                fragment Right on User {
                    name @customDirective(level: 1)
                }
            "#
    ));

    assert!(are_selections_equal(
        // We don't compare arguments for field identities
        r#"
                fragment Left on User {
                    firstName(if: true, unless: false)
                }
                fragment Right on User {
                    firstName(if: false, unless: true)
                }
            "#
    ));

    assert!(are_selections_equal(
        r#"
                fragment Left on User {
                    zucktown: hometown @customDirective(level: 1){
                        id
                        lastName
                    }
                }
                fragment Right on User {
                    zucktown: hometown @customDirective(level: 1){
                        id
                        lastName
                    }
                }
            "#
    ));
}

#[test]
fn test_inline_fragments() {
    assert!(are_selections_equal(
        r#"
                fragment Left on Actor {
                    ... on User {
                        name
                    }
                }
                fragment Right on User {
                    ... on User {
                        name
                    }
                }
            "#
    ));

    assert!(!are_selections_equal(
        r#"
                fragment Left on Actor {
                    ... on Actor {
                        name
                    }
                }
                fragment Right on Actor {
                    ... on User {
                        name
                    }
                }
            "#
    ));

    assert!(!are_selections_equal(
        // We compare directives for inline fragments in Rust
        r#"
                fragment Left on Actor {
                    ... on User @defer(label: "Zuck") {
                        name
                    }
                }
                fragment Right on User {
                    ... on User @defer(label: "Mark") {
                        name
                    }
                }
            "#
    ));
}

#[test]
fn test_fragment_spreads() {
    assert!(are_selections_equal(
        r#"
                fragment Left on User {
                    ...CommonFragment
                }
                fragment Right on User {
                    ...CommonFragment
                }
                fragment CommonFragment on User {
                    name
                }
            "#
    ));

    assert!(!are_selections_equal(
        r#"
                fragment Left on User {
                    ...SpreadLeft
                }
                fragment Right on User {
                    ...Left
                }
                fragment SpreadLeft on User {
                    name
                }
            "#
    ));

    assert!(are_selections_equal(
        r#"
                fragment Left on User {
                    ...CommonFragment @arguments(pictureSize: [42])
                }
                fragment Right on User {
                    ...CommonFragment @arguments(pictureSize: [42])
                }
                fragment CommonFragment on User
                    @argumentDefinitions(pictureSize: {type: "[Int]"}) {
                    profilePicture(size: $pictureSize) {
                        uri
                    }
                }
            "#
    ));

    assert!(!are_selections_equal(
        // Fragment spread with different arguments are not equal
        r#"
                fragment Left on User {
                    ...CommonFragment @arguments(pictureSize: [0])
                }
                fragment Right on User {
                    ...CommonFragment @arguments(pictureSize: [42])
                }
                fragment CommonFragment on User
                    @argumentDefinitions(pictureSize: {type: "[Int]"}) {
                    profilePicture(size: $pictureSize) {
                        uri
                    }
                }
            "#
    ));

    assert!(are_selections_equal(
        // Ignore null arguments
        r#"
                fragment Left on User {
                    ...CommonFragment @arguments(pictureSize: [42], arg: null)
                }
                fragment Right on User {
                    ...CommonFragment @arguments(arg: null, pictureSize: [42])
                }
                fragment CommonFragment on User
                    @argumentDefinitions(pictureSize: {type: "[Int]"}, arg: {type: "Int"}) {
                    profilePicture(size: $pictureSize) {
                        uri
                    }
                }
            "#
    ));
}

#[test]
fn test_conditions() {
    assert!(are_selections_equal(
        r#"
                fragment Left on User {
                    ...CommonFragment @include(if: $conditional1) @skip(if: $conditional3)
                }
                fragment Right on User {
                    ...CommonFragment @include(if: $conditional1) @skip(if: $conditional3)
                }
                fragment CommonFragment on User {
                    name
                }
            "#
    ));

    assert!(!are_selections_equal(
        r#"
            fragment Left on User {
                ...CommonFragment @include(if: $conditional1)
            }
            fragment Right on User {
                ...CommonFragment @include(if: $conditional2)
            }
            fragment CommonFragment on User {
                name
            }
            "#
    ));
}


/*
 * 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<<ef1e560195f38ffa3dfa378616422601>>
 */

mod provided_variable_fragment_transform;

use provided_variable_fragment_transform::transform_fixture;
use fixture_tests::test_fixture;

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

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

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

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

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

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

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