// Copyright 2015 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/main/cpp/blaze_util.h"

#include <fcntl.h>
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>

#include <string>
#include <vector>

#include "src/main/cpp/util/file.h"
#include "googlemock/include/gmock/gmock.h"
#include "googletest/include/gtest/gtest.h"

namespace blaze {

using std::string;
using ::testing::HasSubstr;

class BlazeUtilTest : public ::testing::Test {
 protected:
  BlazeUtilTest() {
  }

  virtual ~BlazeUtilTest() {
  }

  static void ForkAndWrite(int fds[], const string& input1,
                           const string& input2) {
    int r = fork();
    if (r == 0) {
      close(fds[0]);
      write(fds[1], input1.c_str(), input1.size());
      usleep(500);  // sleep for 50ms
      write(fds[1], input2.c_str(), input2.size());
      close(fds[1]);
      exit(0);
    } else if (r < 0) {
      perror("fork()");
      FAIL();
    } else {
      close(fds[1]);
    }
  }

  static int WriteFileDescriptor2(const string& input1, const string& input2) {
    // create a fd for the input string
    int fds[2];
    if (pipe(fds) == -1) {
      return -1;
    }
    if (fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1
        || fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1) {
      return -1;
    }
    if (!input2.empty()) {
      ForkAndWrite(fds, input1, input2);
    } else {
      write(fds[1], input1.c_str(), input1.size());
      close(fds[1]);
    }
    return fds[0];
  }

  static void AssertReadFrom2(const string& input1, const string& input2) {
    int fd = WriteFileDescriptor2(input1, input2);
    if (fd < 0) {
      FAIL() << "Unable to create a pipe!";
    } else {
      string result;
      bool success = blaze_util::ReadFrom(fd, &result);
      close(fd);
      if (!success) {
        perror("ReadFrom");
        FAIL() << "Unable to read file descriptor!";
      } else {
        ASSERT_EQ(input1 + input2, result);
      }
    }
  }

  static void AssertReadFrom(string input) { AssertReadFrom2(input, ""); }

  void ReadFromTest() const {
    AssertReadFrom(
        "DummyJDK Blabla\n"
        "More DummyJDK Blabla\n");
    AssertReadFrom(
        "dummyjdk version \"1.42.qual\"\n"
        "DummyJDK Blabla\n"
        "More DummyJDK Blabla\n");
    AssertReadFrom2("first_line\n", "second line version \"1.4.2_0\"\n");
  }
};

TEST_F(BlazeUtilTest, ReadFrom) { ReadFromTest(); }

TEST_F(BlazeUtilTest, TestSearchNullaryEmptyCase) {
  ASSERT_FALSE(SearchNullaryOption({}, "flag", false));
  ASSERT_TRUE(SearchNullaryOption({}, "flag", true));
}

TEST_F(BlazeUtilTest, TestSearchNullaryForEmpty) {
  ASSERT_TRUE(SearchNullaryOption({"bazel", "build", ":target"}, "", true));
  ASSERT_FALSE(SearchNullaryOption({"bazel", "build", ":target"}, "", false));
}

TEST_F(BlazeUtilTest, TestSearchNullaryForFlagNotPresent) {
  ASSERT_FALSE(SearchNullaryOption({"bazel", "build", ":target"},
                                   "flag", false));
  ASSERT_TRUE(SearchNullaryOption({"bazel", "build", ":target"},
                                   "flag", true));
}

TEST_F(BlazeUtilTest, TestSearchNullaryStartupOption) {
  ASSERT_TRUE(SearchNullaryOption({"bazel", "--flag", "build", ":target"},
                                  "flag", false));
  ASSERT_TRUE(SearchNullaryOption({"bazel", "--flag", "build", ":target"},
                                  "flag", true));
}

TEST_F(BlazeUtilTest, TestSearchNullaryStartupOptionWithEquals) {
  ASSERT_DEATH(SearchNullaryOption(
      {"bazel", "--flag=value", "build", ":target"}, "flag", false),
              "In argument '--flag=value': option "
              "'--flag' does not take a value");
}

TEST_F(BlazeUtilTest, TestSearchNullaryCommandOption) {
  ASSERT_TRUE(SearchNullaryOption({"bazel", "build", ":target", "--flag"},
                                  "flag", false));
}

TEST_F(BlazeUtilTest, TestSearchNullarySkipsAfterDashDash) {
  ASSERT_FALSE(SearchNullaryOption(
      {"bazel", "build", ":target", "--", "--flag"}, "flag", false));
}

TEST_F(BlazeUtilTest, TestSearchNullarySucceedsWithEqualsAndDashDash) {
  ASSERT_FALSE(SearchNullaryOption(
      {"bazel", "build", ":target", "--", "--flag=value"}, "flag", false));
}

TEST_F(BlazeUtilTest, TestSearchNullaryLastFlagWins) {
  ASSERT_FALSE(SearchNullaryOption(
      {"bazel", "--flag", "--noflag", "build"}, "flag", false));
  ASSERT_FALSE(SearchNullaryOption(
      {"bazel", "--flag", "--noflag", "build"}, "flag", true));
}

void assert_equal_vector_char_pointer(std::vector<std::string> expected,
                                      std::vector<std::string> actual) {
  ASSERT_THAT(actual, testing::ContainerEq(expected));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryForEmpty) {
  assert_equal_vector_char_pointer(
      {}, GetAllUnaryOptionValues({"bazel", "build", ":target"}, ""));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryFlagNotPresent) {
  assert_equal_vector_char_pointer(
      {}, GetAllUnaryOptionValues({"bazel", "build", ":target"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithEquals) {
  assert_equal_vector_char_pointer(
      {"value"}, GetAllUnaryOptionValues(
                     {"bazel", "--flag=value", "build", ":target"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithEquals2) {
  assert_equal_vector_char_pointer(
      {"value1", "value2"},
      GetAllUnaryOptionValues(
          {"bazel", "--flag=value1", "--flag=value2", "build", ":target"},
          "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithRepeatingFlag) {
  assert_equal_vector_char_pointer(
      {"--flag"}, GetAllUnaryOptionValues({"bazel", "--flag", "--flag",
                                           "value1", "build", ":target"},
                                          "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithRepeatingFlagOptions) {
  assert_equal_vector_char_pointer(
      {"--flag"}, GetAllUnaryOptionValues(
                      {"bazel", "--flag", "--flag", "value1"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionValuesWithEquals) {
  assert_equal_vector_char_pointer(
      {"--flag", "value1"},
      GetAllUnaryOptionValues({"bazel", "--flag=--flag", "--flag", "value1"},
                              "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithEquals3) {
  assert_equal_vector_char_pointer(
      {"value1", "value2", "value3"},
      GetAllUnaryOptionValues({"bazel", "--flag=value1", "--flag=value2",
                               "--flag=value3", "build", ":target"},
                              "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithoutEquals) {
  assert_equal_vector_char_pointer(
      {"value"},
      GetAllUnaryOptionValues({"bazel", "--flag", "value", "build", ":target"},
                              "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryOptionWithoutEquals2) {
  assert_equal_vector_char_pointer(
      {"value1", "value2"},
      GetAllUnaryOptionValues(
          {"bazel", "--flag", "value1", "--flag", "value2", "build", ":target"},
          "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithEquals) {
  assert_equal_vector_char_pointer(
      {"value"},
      GetAllUnaryOptionValues({"bazel", "build", ":target", "--flag", "value"},
                              "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithEquals2) {
  assert_equal_vector_char_pointer(
      {"value1", "value2"},
      GetAllUnaryOptionValues(
          {"bazel", "build", ":target", "--flag", "value1", "--flag", "value2"},
          "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithoutEquals) {
  assert_equal_vector_char_pointer(
      {"value"}, GetAllUnaryOptionValues(
                     {"bazel", "build", ":target", "--flag=value"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithoutEquals2) {
  assert_equal_vector_char_pointer(
      {"value1", "value2"},
      GetAllUnaryOptionValues(
          {"bazel", "build", ":target", "--flag=value1", "--flag=value2"},
          "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnarySkipsAfterDashDashWithEquals) {
  assert_equal_vector_char_pointer(
      {},
      GetAllUnaryOptionValues(
          {"bazel", "build", ":target", "--", "--flag", "value"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnarySkipsAfterDashDashWithoutEquals) {
  assert_equal_vector_char_pointer(
      {}, GetAllUnaryOptionValues(
              {"bazel", "build", ":target", "--", "--flag=value"}, "--flag"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithIgnoreAfter) {
  assert_equal_vector_char_pointer(
      {"value1", "/dev/null"},
      GetAllUnaryOptionValues({"bazel", "build", ":target", "--flag", "value1",
                               "--flag", "/dev/null", "--flag", "value3"},
                              "--flag", "/dev/null"));
}

TEST_F(BlazeUtilTest, TestGetAllUnaryCommandOptionWithIgnoreAfterDevNull) {
  assert_equal_vector_char_pointer(
      {"/dev/null"}, GetAllUnaryOptionValues(
                         {"bazel", "build", ":target", "--flag", "/dev/null",
                          "--flag", "value2", "--flag", "value3"},
                         "--flag", "/dev/null"));
}

}  // namespace blaze