//===- unittest/Support/RemarksParsingTest.cpp - OptTable tests --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm-c/Remarks.h"
#include "gtest/gtest.h"

using namespace llvm;

template <size_t N> bool tryParse(const char (&Buf)[N]) {
  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
  LLVMRemarkEntry *Remark = nullptr;
  while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
    EXPECT_TRUE(Remark == nullptr); // Only one remark per test.
    Remark = NewRemark;
  }
  EXPECT_TRUE(Remark != nullptr); // We need *exactly* one remark per test.
  bool HasError = LLVMRemarkParserHasError(Parser);
  LLVMRemarkParserDispose(Parser);
  return !HasError;
}

template <size_t N>
bool parseExpectError(const char (&Buf)[N], const char *Error) {
  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
  LLVMRemarkEntry *Remark = nullptr;
  while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
    EXPECT_FALSE(NewRemark);
  }
  EXPECT_TRUE(Remark == nullptr); // We are parsing only one malformed remark.
  EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
  bool MatchesError =
      StringRef(LLVMRemarkParserGetErrorMessage(Parser)).contains(Error);
  LLVMRemarkParserDispose(Parser);

  return MatchesError;
}

TEST(Remarks, RemarksParsingEmpty) {
  StringRef Buf = "\n"
                  "\n";
  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf.data(), Buf.size());
  LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser);
  EXPECT_TRUE(NewRemark == nullptr); // No remark expected.
  EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
  EXPECT_TRUE(StringRef(LLVMRemarkParserGetErrorMessage(Parser))
                  .contains("document root is not of mapping type."));
  LLVMRemarkParserDispose(Parser);
}

TEST(Remarks, RemarksParsingGood) {
  EXPECT_TRUE(tryParse("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
                       "Function: foo\n"
                       "Args:\n"
                       "  - Callee: bar\n"
                       "  - String: ' will not be inlined into '\n"
                       "  - Caller: foo\n"
                       "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                       "  - String: ' because its definition is unavailable'\n"
                       ""));

  // No debug loc should also pass.
  EXPECT_TRUE(tryParse("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "Args:\n"
                       "  - Callee: bar\n"
                       "  - String: ' will not be inlined into '\n"
                       "  - Caller: foo\n"
                       "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                       "  - String: ' because its definition is unavailable'\n"
                       ""));

  // No args is also ok.
  EXPECT_TRUE(tryParse("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
                       "Function: foo\n"
                       ""));

  // Different order.
  EXPECT_TRUE(tryParse("\n"
                       "--- !Missed\n"
                       "DebugLoc: { Line: 3, Column: 12, File: file.c }\n"
                       "Function: foo\n"
                       "Name: NoDefinition\n"
                       "Args:\n"
                       "  - Callee: bar\n"
                       "  - String: ' will not be inlined into '\n"
                       "  - Caller: foo\n"
                       "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                       "  - String: ' because its definition is unavailable'\n"
                       "Pass: inline\n"
                       ""));
}

// Mandatory common part of a remark.
#define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
// Test all the types.
TEST(Remarks, RemarksParsingTypes) {
  // Type: Passed
  EXPECT_TRUE(tryParse("--- !Passed" COMMON_REMARK));
  // Type: Missed
  EXPECT_TRUE(tryParse("--- !Missed" COMMON_REMARK));
  // Type: Analysis
  EXPECT_TRUE(tryParse("--- !Analysis" COMMON_REMARK));
  // Type: AnalysisFPCompute
  EXPECT_TRUE(tryParse("--- !AnalysisFPCompute" COMMON_REMARK));
  // Type: AnalysisAliasing
  EXPECT_TRUE(tryParse("--- !AnalysisAliasing" COMMON_REMARK));
  // Type: Failure
  EXPECT_TRUE(tryParse("--- !Failure" COMMON_REMARK));
}
#undef COMMON_REMARK

TEST(Remarks, RemarksParsingMissingFields) {
  // No type.
  EXPECT_TRUE(parseExpectError("\n"
                               "---\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "",
                               "error: Type, Pass, Name or Function missing."));
  // No pass.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "",
                               "error: Type, Pass, Name or Function missing."));
  // No name.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Function: foo\n"
                               "",
                               "error: Type, Pass, Name or Function missing."));
  // No function.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "",
                               "error: Type, Pass, Name or Function missing."));
  // Debug loc but no file.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "DebugLoc: { Line: 3, Column: 12 }\n"
                               "",
                               "DebugLoc node incomplete."));
  // Debug loc but no line.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "DebugLoc: { File: file.c, Column: 12 }\n"
                               "",
                               "DebugLoc node incomplete."));
  // Debug loc but no column.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "DebugLoc: { File: file.c, Line: 3 }\n"
                               "",
                               "DebugLoc node incomplete."));
}

TEST(Remarks, RemarksParsingWrongTypes) {
  // Wrong debug loc type.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "DebugLoc: foo\n"
                               "",
                               "expected a value of mapping type."));
  // Wrong line type.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "DebugLoc: { File: file.c, Line: b, Column: 12 }\n"
                       "",
                       "expected a value of integer type."));
  // Wrong column type.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "DebugLoc: { File: file.c, Line: 3, Column: c }\n"
                       "",
                       "expected a value of integer type."));
  // Wrong args type.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "Args: foo\n"
                               "",
                               "wrong value type for key."));
  // Wrong key type.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "{ A: a }: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "",
                               "key is not a string."));
  // Debug loc with unknown entry.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "DebugLoc: { File: file.c, Column: 12, Unknown: 12 }\n"
                       "",
                       "unknown entry in DebugLoc map."));
  // Unknown entry.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Unknown: inline\n"
                               "",
                               "unknown key."));
  // Not a scalar.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: { File: a, Line: 1, Column: 2 }\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "",
                               "expected a value of scalar type."));
  // Not a string file in debug loc.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "DebugLoc: { File: { a: b }, Column: 12, Line: 12 }\n"
                       "",
                       "expected a value of scalar type."));
  // Not a integer column in debug loc.
  EXPECT_TRUE(parseExpectError(
      "\n"
      "--- !Missed\n"
      "Pass: inline\n"
      "Name: NoDefinition\n"
      "Function: foo\n"
      "DebugLoc: { File: file.c, Column: { a: b }, Line: 12 }\n"
      "",
      "expected a value of scalar type."));
  // Not a integer line in debug loc.
  EXPECT_TRUE(parseExpectError(
      "\n"
      "--- !Missed\n"
      "Pass: inline\n"
      "Name: NoDefinition\n"
      "Function: foo\n"
      "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
      "",
      "expected a value of scalar type."));
  // Not a mapping type value for args.
  EXPECT_TRUE(parseExpectError(
      "\n"
      "--- !Missed\n"
      "Pass: inline\n"
      "Name: NoDefinition\n"
      "Function: foo\n"
      "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
      "",
      "expected a value of scalar type."));
}

TEST(Remarks, RemarksParsingWrongArgs) {
  // Multiple debug locs per arg.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "Args:\n"
                       "  - Str: string\n"
                       "    DebugLoc: { File: a, Line: 1, Column: 2 }\n"
                       "    DebugLoc: { File: a, Line: 1, Column: 2 }\n"
                       "",
                       "only one DebugLoc entry is allowed per argument."));
  // Multiple strings per arg.
  EXPECT_TRUE(
      parseExpectError("\n"
                       "--- !Missed\n"
                       "Pass: inline\n"
                       "Name: NoDefinition\n"
                       "Function: foo\n"
                       "Args:\n"
                       "  - Str: string\n"
                       "    Str2: string\n"
                       "    DebugLoc: { File: a, Line: 1, Column: 2 }\n"
                       "",
                       "only one string entry is allowed per argument."));
  // No arg value.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "Args:\n"
                               "  - Callee: ''\n"
                               "  - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
                               "",
                               "argument value is missing."));
  // No arg value.
  EXPECT_TRUE(parseExpectError("\n"
                               "--- !Missed\n"
                               "Pass: inline\n"
                               "Name: NoDefinition\n"
                               "Function: foo\n"
                               "Args:\n"
                               "  - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
                               "",
                               "argument key is missing."));
}

TEST(Remarks, RemarksGoodStruct) {
  StringRef Buf = "\n"
                  "--- !Missed\n"
                  "Pass: inline\n"
                  "Name: NoDefinition\n"
                  "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
                  "Function: foo\n"
                  "Args:\n"
                  "  - Callee: bar\n"
                  "  - String: ' will not be inlined into '\n"
                  "  - Caller: foo\n"
                  "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                  "  - String: ' because its definition is unavailable'\n"
                  "\n";

  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf.data(), Buf.size());
  LLVMRemarkEntry *Remark = LLVMRemarkParserGetNext(Parser);
  EXPECT_FALSE(Remark == nullptr);
  EXPECT_EQ(StringRef(Remark->RemarkType.Str, 7), "!Missed");
  EXPECT_EQ(Remark->RemarkType.Len, 7U);
  EXPECT_EQ(StringRef(Remark->PassName.Str, 6), "inline");
  EXPECT_EQ(Remark->PassName.Len, 6U);
  EXPECT_EQ(StringRef(Remark->RemarkName.Str, 12), "NoDefinition");
  EXPECT_EQ(Remark->RemarkName.Len, 12U);
  EXPECT_EQ(StringRef(Remark->FunctionName.Str, 3), "foo");
  EXPECT_EQ(Remark->FunctionName.Len, 3U);
  EXPECT_EQ(StringRef(Remark->DebugLoc.SourceFile.Str, 6), "file.c");
  EXPECT_EQ(Remark->DebugLoc.SourceFile.Len, 6U);
  EXPECT_EQ(Remark->DebugLoc.SourceLineNumber, 3U);
  EXPECT_EQ(Remark->DebugLoc.SourceColumnNumber, 12U);
  EXPECT_EQ(Remark->Hotness, 0U);
  EXPECT_EQ(Remark->NumArgs, 4U);
  // Arg 0
  {
    LLVMRemarkArg &Arg = Remark->Args[0];
    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Callee");
    EXPECT_EQ(Arg.Key.Len, 6U);
    EXPECT_EQ(StringRef(Arg.Value.Str, 3), "bar");
    EXPECT_EQ(Arg.Value.Len, 3U);
    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
  }
  // Arg 1
  {
    LLVMRemarkArg &Arg = Remark->Args[1];
    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
    EXPECT_EQ(Arg.Key.Len, 6U);
    EXPECT_EQ(StringRef(Arg.Value.Str, 26), " will not be inlined into ");
    EXPECT_EQ(Arg.Value.Len, 26U);
    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
  }
  // Arg 2
  {
    LLVMRemarkArg &Arg = Remark->Args[2];
    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Caller");
    EXPECT_EQ(Arg.Key.Len, 6U);
    EXPECT_EQ(StringRef(Arg.Value.Str, 3), "foo");
    EXPECT_EQ(Arg.Value.Len, 3U);
    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 6), "file.c");
    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 6U);
    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 2U);
    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
  }
  // Arg 3
  {
    LLVMRemarkArg &Arg = Remark->Args[3];
    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
    EXPECT_EQ(Arg.Key.Len, 6U);
    EXPECT_EQ(StringRef(Arg.Value.Str, 38),
              " because its definition is unavailable");
    EXPECT_EQ(Arg.Value.Len, 38U);
    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
  }

  EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);

  EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
  LLVMRemarkParserDispose(Parser);
}