// Copyright 2019 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 <fidl/flat_ast.h>
#include <fidl/lexer.h>
#include <fidl/names.h>
#include <fidl/parser.h>
#include <fidl/source_file.h>
#include <zxtest/zxtest.h>

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

namespace {

TEST(UnionTests, GoodKeywordsAsFieldNames) {
  TestLibrary library(R"FIDL(
library test;

struct struct {
    bool field;
};

union Foo {
    1: int64 union;
    2: bool library;
    3: uint32 uint32;
    4: struct member;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);
}

TEST(UnionTests, GoodRecursiveUnion) {
  TestLibrary library(R"FIDL(
library test;

union Value {
  1: bool bool_value;
  2: vector<Value?> list_value;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);
}

TEST(UnionTests, GoodMutuallyRecursive) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  1: Bar bar;
};

struct Bar {
  Foo? foo;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);
}

TEST(UnionTests, GoodFlexibleUnion) {
  TestLibrary library(R"FIDL(
library test;

flexible union Foo {
  1: string bar;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);
}

TEST(UnionTests, GoodStrictUnion) {
  TestLibrary library(R"FIDL(
library test;

strict union Foo {
  1: string bar;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);
}

TEST(UnionTests, BadMustHaveExplicitOrdinalsOld) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
    int64 foo;
    vector<uint32>:10 bar;
};

)FIDL");
  ASSERT_ERRORED_TWICE_DURING_COMPILE(library, fidl::ErrMissingOrdinalBeforeType,
                                      fidl::ErrMissingOrdinalBeforeType);
}

TEST(UnionTests, BadMustHaveExplicitOrdinals) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Foo = strict union {
    foo int64;
    bar vector<uint32>:10;
};

)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_TWICE_DURING_COMPILE(library, fidl::ErrMissingOrdinalBeforeType,
                                      fidl::ErrMissingOrdinalBeforeType);
}

TEST(UnionTests, GoodExplicitOrdinals) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  1: int64 foo;
  2: vector<uint32>:10 bar;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);

  auto fidl_union = library.LookupUnion("Foo");
  ASSERT_NOT_NULL(fidl_union);

  ASSERT_EQ(fidl_union->members.size(), 2);
  auto& member0 = fidl_union->members[0];
  EXPECT_NOT_NULL(member0.maybe_used);
  EXPECT_EQ(member0.ordinal->value, 1);
  auto& member1 = fidl_union->members[1];
  EXPECT_NOT_NULL(member1.maybe_used);
  EXPECT_EQ(member1.ordinal->value, 2);
}

TEST(UnionTests, GoodOrdinalsWithReserved) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  1: reserved;
  2: int64 foo;
  3: reserved;
  4: vector<uint32>:10 bar;
  5: reserved;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);

  auto fidl_union = library.LookupUnion("Foo");
  ASSERT_NOT_NULL(fidl_union);

  ASSERT_EQ(fidl_union->members.size(), 5);
  auto& member0 = fidl_union->members[0];
  EXPECT_NULL(member0.maybe_used);
  EXPECT_EQ(member0.ordinal->value, 1);
  auto& member1 = fidl_union->members[1];
  EXPECT_NOT_NULL(member1.maybe_used);
  EXPECT_EQ(member1.ordinal->value, 2);
  auto& member2 = fidl_union->members[2];
  EXPECT_NULL(member2.maybe_used);
  EXPECT_EQ(member2.ordinal->value, 3);
  auto& member3 = fidl_union->members[3];
  EXPECT_NOT_NULL(member3.maybe_used);
  EXPECT_EQ(member3.ordinal->value, 4);
  auto& member4 = fidl_union->members[4];
  EXPECT_NULL(member4.maybe_used);
  EXPECT_EQ(member4.ordinal->value, 5);
}

TEST(UnionTests, GoodOrdinalsOutOfOrder) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  5: int64 foo;
  2: vector<uint32>:10 bar;
  3: reserved;
  1: reserved;
  4: uint32 baz;
};
)FIDL");
  ASSERT_COMPILED_AND_CONVERT(library);

  auto fidl_union = library.LookupUnion("Foo");
  ASSERT_NOT_NULL(fidl_union);

  ASSERT_EQ(fidl_union->members.size(), 5);
  auto& member0 = fidl_union->members[0];
  EXPECT_NOT_NULL(member0.maybe_used);
  EXPECT_EQ(member0.ordinal->value, 5);
  auto& member1 = fidl_union->members[1];
  EXPECT_NOT_NULL(member1.maybe_used);
  EXPECT_EQ(member1.ordinal->value, 2);
  auto& member2 = fidl_union->members[2];
  EXPECT_NULL(member2.maybe_used);
  EXPECT_EQ(member2.ordinal->value, 3);
  auto& member3 = fidl_union->members[3];
  EXPECT_NULL(member3.maybe_used);
  EXPECT_EQ(member3.ordinal->value, 1);
  auto& member4 = fidl_union->members[4];
  EXPECT_NOT_NULL(member4.maybe_used);
  EXPECT_EQ(member4.ordinal->value, 4);
}

TEST(UnionTests, BadOrdinalOutOfBoundsOld) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  -1: uint32 foo;
};
)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrOrdinalOutOfBound);
}

TEST(UnionTests, BadOrdinalOutOfBounds) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Foo = strict union {
  -1: uint32 foo;
};
)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrOrdinalOutOfBound);
}

TEST(UnionTests, BadOrdinalsMustBeUniqueOld) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  1: reserved;
  1: uint64 x;
};
)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrDuplicateUnionMemberOrdinal);
}

TEST(UnionTests, BadOrdinalsMustBeUnique) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Foo = strict union {
  1: reserved;
  1: uint64 x;
};
)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrDuplicateUnionMemberOrdinal);
}

TEST(UnionTests, BadMemberNamesMustBeUniqueOld) {
  TestLibrary library(R"FIDL(
library test;

union Duplicates {
    1: string s;
    2: int32 s;
};
)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrDuplicateUnionMemberName);
}

TEST(UnionTests, BadMemberNamesMustBeUnique) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Duplicates = strict union {
    1: s string;
    2: s int32;
};
)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrDuplicateUnionMemberName);
}

TEST(UnionTests, BadCannotStartAtZeroOld) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
  0: uint32 foo;
  1: uint64 bar;
};
)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrOrdinalsMustStartAtOne);
}

TEST(UnionTests, BadCannotStartAtZero) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Foo = strict union {
  0: foo uint32;
  1: bar uint64;
};
)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrOrdinalsMustStartAtOne);
}

TEST(UnionTests, BadDefaultNotAllowedOld) {
  TestLibrary library(R"FIDL(
library test;

union Foo {
    1: int64 t = 1;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrDefaultsOnUnionsNotSupported);
}

// NOTE(fxbug.dev/72924): we lose the default specific error in the new syntax.
TEST(UnionTests, BadDefaultNotAllowed) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library test;

type Foo = strict union {
    1: t int64 = 1;
};

)FIDL",
                      std::move(experimental_flags));
  // NOTE(fxbug.dev/72924): we lose the default specific error in the new syntax.
  // TODO(fxbug.dev/72924): the second error doesn't make any sense
  ASSERT_ERRORED_TWICE_DURING_COMPILE(library, fidl::ErrUnexpectedTokenOfKind,
                                      fidl::ErrMissingOrdinalBeforeType);
}

TEST(UnionTests, BadMustBeDenseOld) {
  TestLibrary library(R"FIDL(
library example;

union Example {
    1: int64 first;
    3: int64 third;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrNonDenseOrdinal);
  ASSERT_SUBSTR(library.errors().at(0)->msg.c_str(), "2");
}

TEST(UnionTests, BadMustBeDense) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Example = strict union {
    1: first int64;
    3: third int64;
};

)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrNonDenseOrdinal);
  ASSERT_SUBSTR(library.errors().at(0)->msg.c_str(), "2");
}

TEST(UnionTests, BadMustHaveNonReservedMemberOld) {
  TestLibrary library(R"FIDL(
library example;

union Foo {
  2: reserved;
  1: reserved;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrMustHaveNonReservedMember);
}

TEST(UnionTests, BadMustHaveNonReservedMember) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Foo = strict union {
  2: reserved;
  1: reserved;
};

)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrMustHaveNonReservedMember);
}

TEST(UnionTests, BadNoNullableMembersOld) {
  TestLibrary library(R"FIDL(
library example;

union Foo {
  1: string? bar;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrNullableUnionMember);
}

TEST(UnionTests, BadNoNullableMembers) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Foo = strict union {
  1: bar string:optional;
};

)FIDL",
                      std::move(experimental_flags));
  // NOTE(fxbug.dev/72924): we get a more general error in the new syntax
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrNullableOrdinaledMember);
}

TEST(UnionTests, BadNoDirectlyRecursiveUnionsOld) {
  TestLibrary library(R"FIDL(
library example;

union Value {
  1: Value value;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrIncludeCycle);
}

TEST(UnionTests, BadNoDirectlyRecursiveUnions) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Value = strict union {
  1: value Value;
};

)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrIncludeCycle);
}

TEST(UnionTests, BadEmptyUnionOld) {
  TestLibrary library(R"FIDL(
library example;

union Foo {};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrMustHaveNonReservedMember);
}

TEST(UnionTests, BadEmptyUnion) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Foo = strict union {};

)FIDL",
                      std::move(experimental_flags));
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrMustHaveNonReservedMember);
}

TEST(UnionTests, GoodErrorSyntaxExplicitOrdinalsOld) {
  TestLibrary error_library(R"FIDL(
library example;
protocol Example {
  Method() -> () error int32;
};
)FIDL");
  ASSERT_TRUE(error_library.Compile());
  const fidl::flat::Union* error_union = error_library.LookupUnion("Example_Method_Result");
  ASSERT_NOT_NULL(error_union);
  ASSERT_EQ(error_union->members.front().ordinal->value, 1);
  ASSERT_EQ(error_union->members.back().ordinal->value, 2);
}

TEST(UnionTests, GoodErrorSyntaxExplicitOrdinals) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary error_library(R"FIDL(
library example;
protocol Example {
  Method() -> () error int32;
};
)FIDL",
                            std::move(experimental_flags));
  ASSERT_TRUE(error_library.Compile());
  const fidl::flat::Union* error_union = error_library.LookupUnion("Example_Method_Result");
  ASSERT_NOT_NULL(error_union);
  ASSERT_EQ(error_union->members.front().ordinal->value, 1);
  ASSERT_EQ(error_union->members.back().ordinal->value, 2);
}

TEST(UnionTests, BadNoSelectorOld) {
  TestLibrary library(R"FIDL(
library example;

union Foo {
  [Selector = "v2"] 1: string v;
};

)FIDL");
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrInvalidAttributePlacement);
  ASSERT_SUBSTR(library.errors()[0]->msg.c_str(), "Selector");
}

TEST(UnionTests, BadNoSelector) {
  fidl::ExperimentalFlags experimental_flags;
  experimental_flags.SetFlag(fidl::ExperimentalFlags::Flag::kAllowNewSyntax);
  TestLibrary library(R"FIDL(
library example;

type Foo = strict union {
  [Selector = "v2"] 1: v string;
};

)FIDL",
                      std::move(experimental_flags));
  // TODO(fxbug.dev/72924): this should become ErrInvalidAttributePlacement
  // as before once attributes are implemented.
  ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrMissingOrdinalBeforeType);
}

// TODO(fxbug.dev/70247): as we clean up the migration, it will probably have
// been long enough that we can remove this error and the special handling for
// "xunion"
TEST(UnionTests, BadDeprecatedXUnionError) {
  {
    TestLibrary library(R"FIDL(
  library test;

  xunion Foo {
    1: string foo;
  };

  )FIDL");
    ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrXunionDeprecated);
  }

  {
    TestLibrary library(R"FIDL(
  library test;

  flexible xunion FlexibleFoo {
    1: string foo;
  };

  )FIDL");
    ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrXunionDeprecated);
  }

  {
    TestLibrary library(R"FIDL(
  library test;

  strict xunion StrictFoo {
    1: string foo;
  };

  )FIDL");
    ASSERT_ERRORED_DURING_COMPILE(library, fidl::ErrStrictXunionDeprecated);
  }
}

}  // namespace