// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <zxtest/zxtest.h>

#include "error_test.h"
#include "test_library.h"

// This file tests the temporal decomposition algorithm by comparing the JSON IR
// resulting from a versioned library and its manually decomposed equivalents.
// See also versioning_tests.cc and availability_interleaving_tests.cc.

namespace {

// Returns true if str starts with prefix.
bool StartsWith(std::string_view str, std::string_view prefix) {
  return str.substr(0, prefix.size()) == prefix;
}

// If the line starts with whitespace followed by str, returns the whitespace.
std::optional<std::string> GetSpaceBefore(std::string_view line, std::string_view str) {
  size_t i = 0;
  while (i < line.size() && line[i] == ' ') {
    i++;
  }
  if (StartsWith(line.substr(i), str)) {
    return std::string(line.substr(0, i));
  }
  return std::nullopt;
}

// Erases all "location" and "maybe_attributes" fields from a JSON IR string.
// These are the only things can change when manually decomposing a library.
// Also removes all end-of-line commas since these can cause spurious diffs.
// Note that this means the returned string is not valid JSON.
std::string ScrubJson(const std::string& json) {
  // We scan the JSON line by line, filtering out the undesired lines. To do
  // this, we rely on JsonWriter emitting correct indentation and newlines.
  std::istringstream input(json);
  std::ostringstream output;
  std::string line;
  std::optional<std::string> skip_until;
  while (std::getline(input, line)) {
    if (skip_until) {
      if (StartsWith(line, skip_until.value())) {
        skip_until = std::nullopt;
      }
    } else {
      if ((skip_until = GetSpaceBefore(line, "\"location\": {"))) {
        skip_until.value().push_back('}');
      } else if ((skip_until = GetSpaceBefore(line, "\"maybe_attributes\": ["))) {
        skip_until.value().push_back(']');
      } else {
        if (line.back() == ',') {
          line.pop_back();
        }
        output << line << '\n';
      }
    }
  }
  return output.str();
}

// Platform name and library name for all test libraries in this file.
const std::string kPlatformName = "example";
const std::vector<std::string_view> kLibraryName = {kPlatformName};

// Helper function to implement ASSERT_EQUIVALENT.
void AssertEquivalent(const std::string& left_fidl, const std::string& right_fidl,
                      std::string_view version) {
  TestLibrary left_lib(left_fidl);
  left_lib.SelectVersion(kPlatformName, version);
  ASSERT_COMPILED(left_lib);
  ASSERT_EQ(left_lib.compilation()->library_name, kLibraryName);
  TestLibrary right_lib(right_fidl);
  right_lib.SelectVersion(kPlatformName, version);
  ASSERT_COMPILED(right_lib);
  ASSERT_EQ(right_lib.compilation()->library_name, kLibraryName);
  auto left_json = ScrubJson(left_lib.GenerateJSON());
  auto right_json = ScrubJson(right_lib.GenerateJSON());
  if (left_json != right_json) {
    std::ofstream output_left("decomposition_tests_left.txt");
    output_left << left_json;
    output_left.close();
    std::ofstream output_right("decomposition_tests_right.txt");
    output_right << right_json;
    output_right.close();
  }
  ASSERT_STREQ(left_json, right_json,
               "To compare results, run:\n\n"
               "diff $(cat $FUCHSIA_DIR/.fx-build-dir)/decomposition_tests_{left,right}.txt\n");
}

// Asserts that left_fidl and right_fidl compile to JSON IR that is identical
// after scrubbbing (see ScrubJson) for the given version. On failure, the
// ASSERT_NO_FAILURES ensures that we report the caller's line number.
#define ASSERT_EQUIVALENT(left_fidl, right_fidl, version) \
  ASSERT_NO_FAILURES(AssertEquivalent(left_fidl, right_fidl, version))

TEST(DecompositionTests, EquivalentToSelf) {
  auto fidl = R"FIDL(
@available(added=1)
library example;
)FIDL";

  ASSERT_EQUIVALENT(fidl, fidl, "1");
  ASSERT_EQUIVALENT(fidl, fidl, "2");
  ASSERT_EQUIVALENT(fidl, fidl, "HEAD");
}

TEST(DecompositionTests, DefaultAddedAtHead) {
  auto with_attribute = R"FIDL(
@available(added=HEAD)
library example;

type Foo = struct {};
)FIDL";

  auto without_attribute = R"FIDL(
library example;

type Foo = struct {};
)FIDL";

  ASSERT_EQUIVALENT(with_attribute, without_attribute, "1");
  ASSERT_EQUIVALENT(with_attribute, without_attribute, "2");
  ASSERT_EQUIVALENT(with_attribute, without_attribute, "HEAD");
}

TEST(DecompositionTests, AbsentLibraryIsEmpty) {
  auto fidl = R"FIDL(
@available(added=2, removed=3)
library example;

type Foo = struct {};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type Foo = struct {};
)FIDL";

  auto v3_to_head = R"FIDL(
@available(added=3)
library example;
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3_to_head, "3");
  ASSERT_EQUIVALENT(fidl, v3_to_head, "HEAD");
}

TEST(DecompositionTests, SplitByMembership) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type TopLevel = struct {
    @available(added=2)
    first uint32;
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type TopLevel = struct {};
)FIDL";

  auto v2_to_head = R"FIDL(
@available(added=2)
library example;

type TopLevel = struct {
    first uint32;
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "2");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "HEAD");
}

TEST(DecompositionTests, SplitByReference) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type This = struct {
    this_member That;
};

type That = struct {
    @available(added=2)
    that_member uint32;
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type This = struct {
    this_member That;
};

type That = struct {};
)FIDL";

  auto v2_to_head = R"FIDL(
@available(added=2)
library example;

type This = struct {
    this_member That;
};

type That = struct {
    that_member uint32;
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "2");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "HEAD");
}

TEST(DecompositionTests, SplitByTwoMembers) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type This = struct {
    @available(added=2)
    first That;
    @available(added=3)
    second That;
};

type That = struct {};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type This = struct {};

type That = struct {};
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type This = struct {
    first That;
};

type That = struct {};
)FIDL";

  auto v3_to_head = R"FIDL(
@available(added=3)
library example;

type This = struct {
    first That;
    second That;
};

type That = struct {};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3_to_head, "3");
  ASSERT_EQUIVALENT(fidl, v3_to_head, "HEAD");
}

TEST(DecompositionTests, Recursion) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type Expr = flexible union {
    1: num int64;

    @available(removed=3)
    2: add struct {
        left Expr:optional;
        right Expr:optional;
    };

    @available(added=2, removed=3)
    3: mul struct {
        left Expr:optional;
        right Expr:optional;
    };

    @available(added=3)
    2: reserved;
    @available(added=3)
    3: reserved;
    @available(added=3)
    4: bin struct {
        kind flexible enum {
            ADD = 1;
            MUL = 2;
            DIV = 3;

            @available(added=4)
            MOD = 4;
        };
        left Expr:optional;
        right Expr:optional;
    };
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type Expr = flexible union {
    1: num int64;
    2: add struct {
        left Expr:optional;
        right Expr:optional;
    };
};
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type Expr = flexible union {
    1: num int64;
    2: add struct {
        left Expr:optional;
        right Expr:optional;
    };
    3: mul struct {
        left Expr:optional;
        right Expr:optional;
    };
};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type Expr = flexible union {
    1: num int64;
    2: reserved;
    3: reserved;
    4: bin struct {
        kind flexible enum {
            ADD = 1;
            MUL = 2;
            DIV = 3;
        };
        left Expr:optional;
        right Expr:optional;
    };
};
)FIDL";

  auto v4_to_head = R"FIDL(
@available(added=4)
library example;

type Expr = flexible union {
    1: num int64;
    2: reserved;
    3: reserved;
    4: bin struct {
        kind flexible enum {
            ADD = 1;
            MUL = 2;
            DIV = 3;
            MOD = 4;
        };
        left Expr:optional;
        right Expr:optional;
    };
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "4");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "HEAD");
}

TEST(DecompositionTests, MutualRecursion) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

@available(added=2)
type Foo = struct {
    str string;
    @available(added=3)
    bars vector<box<Bar>>;
};

@available(added=2)
type Bar = struct {
    @available(removed=5)
    foo box<Foo>;
    @available(added=4)
    str string;
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type Foo = struct {
    str string;
};

type Bar = struct {
    foo box<Foo>;
};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type Foo = struct {
    str string;
    bars vector<box<Bar>>;
};

type Bar = struct {
    foo box<Foo>;
};
)FIDL";

  auto v4 = R"FIDL(
@available(added=4, removed=5)
library example;

type Foo = struct {
    str string;
    bars vector<box<Bar>>;
};

type Bar = struct {
    foo box<Foo>;
    str string;
};
)FIDL";

  auto v5_to_head = R"FIDL(
@available(added=5)
library example;

type Foo = struct {
    str string;
    bars vector<box<Bar>>;
};

type Bar = struct {
    str string;
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4, "4");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "5");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "HEAD");
}

TEST(DecompositionTests, MisalignedSwapping) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

@available(removed=4)
const LEN uint64 = 16;
@available(added=4)
const LEN uint64 = 32;

@available(added=2)
type Foo = table {
    @available(removed=3)
    1: bar string;
    @available(added=3)
    1: bar string:LEN;
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

const LEN uint64 = 16;
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

const LEN uint64 = 16;
type Foo = table {
    1: bar string;
};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

const LEN uint64 = 16;
type Foo = table {
    1: bar string:LEN;
};
)FIDL";

  auto v4_to_head = R"FIDL(
@available(added=4)
library example;

const LEN uint64 = 32;
type Foo = table {
    1: bar string:LEN;
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "4");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "HEAD");
}

TEST(DecompositionTests, StrictToFlexible) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type X = struct {
    @available(added=2, removed=4)
    y Y;
};

@available(added=2, removed=3)
type Y = strict enum { A = 1; };

@available(added=3)
type Y = flexible enum { A = 1; };
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type X = struct {};
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type X = struct {
    y Y;
};

type Y = strict enum { A = 1; };
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type X = struct {
    y Y;
};

type Y = flexible enum { A = 1; };
)FIDL";

  auto v4_to_head = R"FIDL(
@available(added=4)
library example;

type X = struct {};

type Y = flexible enum { A = 1; };
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "4");
  ASSERT_EQUIVALENT(fidl, v4_to_head, "HEAD");
}

TEST(DecompositionTests, NameReuse) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

@available(added=2, removed=3)
type Foo = struct {
    bar Bar;
};
@available(added=1, removed=4)
type Bar = struct {};

@available(added=4, removed=7)
type Foo = struct {};
@available(added=4, removed=6)
type Bar = struct {
    foo Foo;
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

type Bar = struct {};
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type Foo = struct {
    bar Bar;
};
type Bar = struct {};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type Bar = struct {};
)FIDL";

  auto v4_to_5 = R"FIDL(
@available(added=4, removed=6)
library example;

type Foo = struct {};
type Bar = struct {
    foo Foo;
};
)FIDL";

  auto v6 = R"FIDL(
@available(added=6, removed=7)
library example;

type Foo = struct {};
)FIDL";

  auto v7_to_head = R"FIDL(
@available(added=7)
library example;
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4_to_5, "4");
  ASSERT_EQUIVALENT(fidl, v4_to_5, "5");
  ASSERT_EQUIVALENT(fidl, v6, "6");
  ASSERT_EQUIVALENT(fidl, v7_to_head, "7");
  ASSERT_EQUIVALENT(fidl, v7_to_head, "HEAD");
}

TEST(DecompositionTests, ConstsAndConstraints) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

@available(removed=4)
const LEN uint64 = 10;

type Foo = table {
    @available(removed=3)
    1: bar Bar;
    @available(added=3, removed=4)
    1: bar string:LEN;
    @available(added=4, removed=5)
    1: bar Bar;
};

@available(removed=2)
type Bar = struct {};
@available(added=2)
type Bar = table {};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;

const LEN uint64 = 10;
type Foo = table {
    1: bar Bar;
};
type Bar = struct {};
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

const LEN uint64 = 10;
type Foo = table {
    1: bar Bar;
};
type Bar = table {};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

const LEN uint64 = 10;
type Foo = table {
    1: bar string:LEN;
};
type Bar = table {};
)FIDL";

  auto v4 = R"FIDL(
@available(added=4, removed=5)
library example;

type Foo = table {
    1: bar Bar;
};
type Bar = table {};
)FIDL";

  auto v5_to_head = R"FIDL(
@available(added=5)
library example;

type Foo = table {};
type Bar = table {};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4, "4");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "5");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "HEAD");
}

TEST(DecompositionTests, AllElementsSplitByMembership) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

@available(added=2, removed=5)
type Bits = bits {
    FIRST = 1;
    @available(added=3, removed=4)
    SECOND = 2;
};

@available(added=2, removed=5)
type Enum = enum {
    FIRST = 1;
    @available(added=3, removed=4)
    SECOND = 2;
};

@available(added=2, removed=5)
type Struct = struct {
    first string;
    @available(added=3, removed=4)
    second string;
};

@available(added=2, removed=5)
type Table = table {
    1: first string;
    @available(added=3, removed=4)
    2: second string;
};

@available(added=2, removed=5)
type Union = union {
    1: first string;
    @available(added=3, removed=4)
    2: second string;
};

@available(added=2, removed=5)
protocol TargetProtocol {};

@available(added=2, removed=5)
protocol ProtocolComposition {
    @available(added=3, removed=4)
    compose TargetProtocol;
};

@available(added=2, removed=5)
protocol ProtocolMethods {
    @available(added=3, removed=4)
    Method() -> ();
};

@available(added=2, removed=5)
service Service {
    first client_end:TargetProtocol;
    @available(added=3, removed=4)
    second client_end:TargetProtocol;
};

@available(added=2, removed=5)
resource_definition Resource : uint32 {
    properties {
        first uint32;
        @available(added=3, removed=4)
        second uint32;
    };
};
)FIDL";

  auto v1 = R"FIDL(
@available(added=1, removed=2)
library example;
)FIDL";

  auto v2 = R"FIDL(
@available(added=2, removed=3)
library example;

type Bits = bits {
    FIRST = 1;
};

type Enum = enum {
    FIRST = 1;
};

type Struct = struct {
    first string;
};

type Table = table {
    1: first string;
};

type Union = union {
    1: first string;
};

protocol TargetProtocol {};

protocol ProtocolComposition {};

protocol ProtocolMethods {};

service Service {
    first client_end:TargetProtocol;
};

resource_definition Resource : uint32 {
    properties {
        first uint32;
    };
};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type Bits = bits {
    FIRST = 1;
    SECOND = 2;
};

type Enum = enum {
    FIRST = 1;
    SECOND = 2;
};

type Struct = struct {
    first string;
    second string;
};

type Table = table {
    1: first string;
    2: second string;
};

type Union = union {
    1: first string;
    2: second string;
};

protocol TargetProtocol {};

protocol ProtocolComposition {
    compose TargetProtocol;
};

protocol ProtocolMethods {
    Method() -> ();
};

service Service {
    first client_end:TargetProtocol;
    second client_end:TargetProtocol;
};

resource_definition Resource : uint32 {
    properties {
        first uint32;
        second uint32;
    };
};
)FIDL";

  auto v4 = R"FIDL(
@available(added=4, removed=5)
library example;

type Bits = bits {
    FIRST = 1;
};

type Enum = enum {
    FIRST = 1;
};

type Struct = struct {
    first string;
};


type Table = table {
    1: first string;
};

type Union = union {
    1: first string;
};

protocol TargetProtocol {};

protocol ProtocolComposition {};

protocol ProtocolMethods {};

service Service {
    first client_end:TargetProtocol;
};

resource_definition Resource : uint32 {
    properties {
        first uint32;
    };
};
)FIDL";

  auto v5_to_head = R"FIDL(
@available(added=5)
library example;
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4, "4");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "5");
  ASSERT_EQUIVALENT(fidl, v5_to_head, "HEAD");
}

TEST(DecompositionTests, AllElementsSplitByReference) {
  auto fidl_prefix = R"FIDL(
@available(added=1)
library example;

@available(removed=2)
const VALUE uint32 = 1;
@available(added=2)
const VALUE uint32 = 2;

@available(removed=2)
type Type = struct {
    value bool;
};
@available(added=2)
type Type = table {
    1: value bool;
};

// Need unsigned integers for bits underlying type.
@available(removed=2)
alias IntegerType = uint32;
@available(added=2)
alias IntegerType = uint64;

// Need uint32/int32 for error type.
@available(removed=2)
alias ErrorIntegerType = uint32;
@available(added=2)
alias ErrorIntegerType = int32;

@available(removed=2)
protocol TargetProtocol {};
@available(added=2)
protocol TargetProtocol {
    Method();
};
)FIDL";

  auto v1_prefix = R"FIDL(
@available(added=1, removed=2)
library example;

const VALUE uint32 = 1;

type Type = struct {
    value bool;
};

alias IntegerType = uint32;

alias ErrorIntegerType = uint32;

protocol TargetProtocol {};
)FIDL";

  auto v2_to_head_prefix = R"FIDL(
@available(added=2)
library example;

const VALUE uint32 = 2;

type Type = table {
    1: value bool;
};

alias IntegerType = uint64;

alias ErrorIntegerType = int32;

protocol TargetProtocol { Method(); };
)FIDL";

  auto common_suffix = R"FIDL(
const CONST uint32 = VALUE;

alias Alias = Type;

// TODO(fxbug.dev/7807): Uncomment.
// type Newtype = Type;

type BitsUnderlying = bits : IntegerType {
    MEMBER = 1;
};

type BitsMemberValue = bits {
    MEMBER = VALUE;
};

type EnumUnderlying = enum : IntegerType {
    MEMBER = 1;
};

type EnumMemberValue = enum {
    MEMBER = VALUE;
};

type StructMemberType = struct {
    member Type;
};

type StructMemberDefault = struct {
    @allow_deprecated_struct_defaults
    member uint32 = VALUE;
};

type Table = table {
    1: member Type;
};

type Union = union {
    1: member Type;
};

protocol ProtocolComposition {
    compose TargetProtocol;
};

protocol ProtocolMethodRequest {
    Method(Type);
};

protocol ProtocolMethodResponse {
    Method() -> (Type);
};

protocol ProtocolEvent {
    -> Event(Type);
};

protocol ProtocolSuccess {
    Method() -> (Type) error uint32;
};

protocol ProtocolError {
    Method() -> (struct {}) error ErrorIntegerType;
};

service Service {
    member client_end:TargetProtocol;
};

resource_definition Resource : uint32 {
    properties {
        first IntegerType;
    };
};

type NestedTypes = struct {
    first vector<Type>;
    second vector<array<Type, 3>>;
};

type LayoutParameters = struct {
    member array<bool, VALUE>;
};

type Constraints = struct {
    member vector<bool>:VALUE;
};

type AnonymousLayouts = struct {
    first_member table {
        1: second_member union {
            1: third_member Type;
        };
    };
};

protocol AnonymousLayoutsInProtocol {
    Request(struct { member Type; });
    Response() -> (struct { member Type; });
    -> Event(struct { member Type; });
    Success() -> (struct { member Type; }) error uint32;
    Error() -> (struct {}) error ErrorIntegerType;
};
)FIDL";

  auto fidl = std::string(fidl_prefix) + common_suffix;
  auto v1 = std::string(v1_prefix) + common_suffix;
  auto v2_to_head = std::string(v2_to_head_prefix) + common_suffix;

  ASSERT_EQUIVALENT(fidl, v1, "1");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "2");
  ASSERT_EQUIVALENT(fidl, v2_to_head, "HEAD");
}

TEST(DecompositionTests, Complicated) {
  auto fidl = R"FIDL(
@available(added=1)
library example;

type X = resource struct {
    @available(removed=7)
    x1 bool;
    @available(added=3)
    x2 Y;
    @available(added=4)
    x3 Z;
};

@available(added=3)
type Y = resource union {
    1: y1 client_end:A;
    @available(added=4, removed=5)
    2: y2 client_end:B;
};

@available(added=3)
type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

@available(added=3)
type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
    @available(added=7)
    A2(resource struct { y Y; });
};

@available(added=3)
protocol B {
    @available(removed=5)
    B1(X);
    @available(added=5)
    B2(resource struct {
      x X;
      y Y;
    });
};

@available(removed=6)
protocol AB {
    compose A;
    @available(added=4)
    compose B;
};
)FIDL";

  auto v1_to_2 = R"FIDL(
@available(added=1, removed=3)
library example;

type X = resource struct {
    x1 bool;
};

protocol A {
    A1(X);
};

protocol AB {
    compose A;
};
)FIDL";

  auto v3 = R"FIDL(
@available(added=3, removed=4)
library example;

type X = resource struct {
    x1 bool;
    x2 Y;
};

type Y = resource union {
    1: y1 client_end:A;
};

type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
};

protocol B {
    B1(X);
};

protocol AB {
    compose A;
};
)FIDL";

  auto v4 = R"FIDL(
@available(added=4, removed=5)
library example;

type X = resource struct {
    x1 bool;
    x2 Y;
    x3 Z;
};

type Y = resource union {
    1: y1 client_end:A;
    2: y2 client_end:B;
};

type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
};

protocol B {
    B1(X);
};

protocol AB {
    compose A;
    compose B;
};
)FIDL";

  auto v5 = R"FIDL(
@available(added=5, removed=6)
library example;

type X = resource struct {
    x1 bool;
    x2 Y;
    x3 Z;
};

type Y = resource union {
    1: y1 client_end:A;
};

type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
};

protocol B {
    B2(resource struct {
      x X;
      y Y;
    });
};

protocol AB {
    compose A;
    compose B;
};
)FIDL";

  auto v6 = R"FIDL(
@available(added=6, removed=7)
library example;

type X = resource struct {
    x1 bool;
    x2 Y;
    x3 Z;
};

type Y = resource union {
    1: y1 client_end:A;
};

type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
};

protocol B {
    B2(resource struct {
      x X;
      y Y;
    });
};
)FIDL";

  auto v7_to_head = R"FIDL(
@available(added=7)
library example;

type X = resource struct {
    x2 Y;
    x3 Z;
};

type Y = resource union {
    1: y1 client_end:A;
};

type Z = resource struct {
    z1 Y:optional;
    z2 vector<W>:optional;
};

type W = resource table {
    1: w1 X;
};

protocol A {
    A1(X);
    A2(resource struct { y Y; });
};

protocol B {
    B2(resource struct {
      x X;
      y Y;
    });
};
)FIDL";

  ASSERT_EQUIVALENT(fidl, v1_to_2, "1");
  ASSERT_EQUIVALENT(fidl, v1_to_2, "2");
  ASSERT_EQUIVALENT(fidl, v3, "3");
  ASSERT_EQUIVALENT(fidl, v4, "4");
  ASSERT_EQUIVALENT(fidl, v5, "5");
  ASSERT_EQUIVALENT(fidl, v6, "6");
  ASSERT_EQUIVALENT(fidl, v7_to_head, "7");
  ASSERT_EQUIVALENT(fidl, v7_to_head, "HEAD");
}

}  // namespace