Gauze¶

#include <iostream> // std::cout
#include <cstdlib> // EXIT_SUCCESS

int gauze_main(int argc, char** argv) {
  std::cout << "Hello, Gauze!" << std::endl;
  return EXIT_SUCCESS;
}

#include <iostream> // std::cout
#include <cstdlib> // EXIT_SUCCESS

int gauze_main(int argc, char** argv) {
  std::cout << "argc = " << argc << std::endl;
  for (int i=0; i<argc; ++i) {
    std::cout << "argv[" << i << "] = " << argv[i] << std::endl;
  }

  return EXIT_SUCCESS;
}

#include <cstdlib> // EXIT_SUCCESS
#include <fstream> // std::ifstream
#include <iostream> // std::cout
#include <string> // std::getline

int gauze_main(int argc, char** argv) {
  std::cout << "argc = " << argc << std::endl;
  for (int i=0; i<argc; ++i) {
    std::cout << "argv[" << i << "] = " << argv[i] << std::endl;
  }

  if(argc < 7) {
    std::cerr << "Unexpected number of arguments: " << argc << std::endl;
    return EXIT_FAILURE;
  }

  const char* filename = argv[4];

  std::ifstream file(filename);
  std::string content;
  std::getline(file, content);

  std::cout << "Content: '" << content << "'" << std::endl;

  return EXIT_SUCCESS;
}

#include <cstdlib> // EXIT_SUCCESS
#include <fstream> // std::ifstream
#include <iostream> // std::cout
#include <string> // std::getline
#include <boost/filesystem.hpp>
#include <sstream> // std::ostringstream

int gauze_main(int argc, char** argv) {
  std::cout << "argc = " << argc << std::endl;
  for (int i=0; i<argc; ++i) {
    std::cout << "argv[" << i << "] = " << argv[i] << std::endl;
  }

  if(argc < 7) {
    std::cerr << "Unexpected number of arguments: " << argc << std::endl;
    return EXIT_FAILURE;
  }

  boost::filesystem::path resdir(argv[4]);

  for (int i=0; i<3; ++i) {
    std::ostringstream file_name;
    file_name << "file." << i;

    boost::filesystem::path file_path(resdir);
    file_path /= file_name.str();

    std::cout << "Processing file: " << file_path << std::endl;
    std::ifstream file(file_path.string());

    std::string content;
    std::getline(file, content);

    if(!file) {
      std::cerr << "Can't read file: " << file_path << std::endl;
      return EXIT_FAILURE;
    }

    std::cout << "Content: '" << content << "'" << std::endl;
  }

  return EXIT_SUCCESS;
}

#include <cstdlib> // EXIT_SUCCESS
#include <iostream> // std::cout
#include <gauze/deplib/Deplib.hpp>

int gauze_main(int argc, char** argv) {
  gauze::deplib::Deplib deplib;
  std::cout << "Result: " << deplib.result() << std::endl;
  return EXIT_SUCCESS;
}

#include <gtest/gtest.h> // TEST

#include <cxxopts.hpp>

#include <fstream>

int argc_;
char** argv_;

int gauze_main(int argc, char** argv) {
  std::cout << "argc = " << argc << std::endl;
  for (int i=0; i<argc; ++i) {
      std::cout << "argv[" << i << "] = " << argv[i] << std::endl;
  }
  argc_ = argc;
  argv_ = argv;
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

TEST(gauze_gtest, arith) {
  ASSERT_EQ(2 + 2, 4);
}

TEST(gauze_gtest, boolean) {
  const bool a = true;
  ASSERT_TRUE(a);
}

static void check_file(const std::string &filename, const std::string &message) {
    std::ifstream ifs(filename);
    ASSERT_TRUE(ifs);
    std::string line((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
    ASSERT_EQ(line, message);
}

TEST(gauze_gtest, cli) {
    
    cxxopts::Options options("gauze-gtest", "Test command line parsing");

    bool a = false;
    int aint = 0;
    float afloat = 0.f;
    std::string astring;
    std::string afile;
    std::string adir;

    bool b = false;
    int bint = 0;
    float bfloat = 0.f;
    std::string bstring;
    std::string bfile;
    std::string bdir;

    // clang-format off
    options.add_options()
        ("a,aval", "equals boolean", cxxopts::value<bool>(a))
        ("aint", "equals integer", cxxopts::value<int>(aint))
        ("afloat", "equals float", cxxopts::value<float>(afloat))
        ("astring", "equals string", cxxopts::value<std::string>(astring))
        ("afile", "equals filename", cxxopts::value<std::string>(afile))
        ("adir", "equals directory", cxxopts::value<std::string>(adir))
    ;
    // clang-format on    
    
    options.parse(argc_, argv_);

    static const std::string message = "Gauze resource file\n";
    
    ASSERT_EQ(a, true);
    ASSERT_EQ(aint, 314159);
    ASSERT_EQ(afloat, 3.14159265359f);
    ASSERT_EQ(astring, "3.14159265359");
    check_file(afile, message);
    check_file(adir + "/input.txt", message);
}

#include <iostream> // std::cout
#include <cstdlib> // EXIT_SUCCESS

int gauze_main(int argc, char** argv)
{
  if (argc != 1)
  {
    std::cerr << "No arguments expected" << std::endl;
    return EXIT_FAILURE;
  }

  const char* var_1_name = "MY_GAUZE_VARIABLE_1";
  const char* var_1 = std::getenv(var_1_name);

  if (var_1 == nullptr)
  {
    std::cerr << "Variable " << var_1_name << " not found" << std::endl;
    return EXIT_FAILURE;
  }

  if (std::string(var_1) != "42")
  {
    std::cerr << "Variable " << var_1_name << " unexpected value" << std::endl;
    return EXIT_FAILURE;
  }

  std::cout << "Variable " << var_1_name << " found!" << std::endl;

  const char* var_2_name = "MY_GAUZE_VARIABLE_2";
  const char* var_2 = std::getenv(var_2_name);

  if (var_2 != nullptr)
  {
    std::cout << var_2_name << " value: " << var_2 << std::endl;
  }

  return EXIT_SUCCESS;
}