Apr 28, 2022 · Apr 25, 2022 · Apr 25, 2022 · Apr 25, 2022 · Apr 25, 2022 · Apr 25, 2022
diff --git a/bootstrap/main.buildcc.cpp b/bootstrap/main.buildcc.cpp
  Reg::Init();
  Reg::Call(Args::Clean()).Func(clean_cb);

  BaseToolchain toolchain = custom_toolchain_arg.ConstructToolchain();
  auto &toolchain = custom_toolchain_arg;
  toolchain.SetToolchainInfoFunc(GlobalToolchainInfo::Get(toolchain.id));

  BuildBuildCC buildcc(
      toolchain, TargetEnv(Project::GetRootDir(), Project::GetBuildDir()));
diff --git a/bootstrap/src/build_buildcc.cpp b/bootstrap/src/build_buildcc.cpp
  target.GlobHeaders("lib/args/include/args");

  // Specialized Toolchains
  target.GlobSources("toolchains/src");
  target.AddIncludeDir("toolchains/include");
  target.GlobHeaders("toolchains/include/toolchains");

diff --git a/buildcc/buildcc.h b/buildcc/buildcc.h
 #include "toolchains/toolchain_gcc.h"
 #include "toolchains/toolchain_msvc.h"
 #include "toolchains/toolchain_mingw.h"
 #include "toolchains/toolchain_generic.h"
 #include "toolchains/toolchain_custom.h"

 #include "toolchains/toolchain_infos.h"

 // TODO, Add more specialized toolchains here

diff --git a/buildcc/lib/args/include/args/args.h b/buildcc/lib/args/include/args/args.h
 * command line
 * Bundled with Toolchain State
 */
 struct ArgToolchain {
  ArgToolchain() = default;
 class ArgToolchain : public Toolchain {
 public:
  ArgToolchain()
      : Toolchain(ToolchainId::Undefined, "", ToolchainExecutables()){};
  ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
               const ToolchainExecutables &initial_executables)
      : id(initial_id), name(initial_name), executables(initial_executables) {}
  ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
               const std::string &initial_assembler,
               const std::string &initial_c_compiler,
               const std::string &initial_cpp_compiler,
               const std::string &initial_archiver,
               const std::string &initial_linker)
      : ArgToolchain(initial_id, initial_name,
                     ToolchainExecutables(initial_assembler, initial_c_compiler,
                                          initial_cpp_compiler,
                                          initial_archiver, initial_linker)) {}

  /**
   * @brief Construct a BaseToolchain from the arguments supplied through the
   * command line information
   */
  // TODO, Update this for lock and ToolchainConfig
  BaseToolchain ConstructToolchain() const {
    return BaseToolchain(id, name, executables);
  }
      : Toolchain(initial_id, initial_name, initial_executables) {}
  [[deprecated]] ArgToolchain(ToolchainId initial_id,
                              const std::string &initial_name,
                              const std::string &initial_assembler,
                              const std::string &initial_c_compiler,
                              const std::string &initial_cpp_compiler,
                              const std::string &initial_archiver,
                              const std::string &initial_linker)
      : Toolchain(initial_id, initial_name,
                  ToolchainExecutables(initial_assembler, initial_c_compiler,
                                       initial_cpp_compiler, initial_archiver,
                                       initial_linker)) {}

 public:
  ArgToolchainState state;
  ToolchainId id{ToolchainId::Undefined};
  std::string name{""};
  ToolchainExecutables executables;
  ToolchainId &id = RefId();
  std::string &name = RefName();
  ToolchainExecutables &executables = RefExecutables();
  ToolchainConfig &config = RefConfig();
 };

 // NOTE, Incomplete without pch_compile_command
diff --git a/buildcc/lib/args/src/register.cpp b/buildcc/lib/args/src/register.cpp

 #include "env/assert_fatal.h"
 #include "env/env.h"
 #include "env/storage.h"

 namespace fs = std::filesystem;


 std::unique_ptr<Reg::Instance> Reg::instance_;

 void SystemInit() {
  Project::Init(fs::current_path() / Args::GetProjectRootDir(),
                fs::current_path() / Args::GetProjectBuildDir());
  env::set_log_level(Args::GetLogLevel());

  // Top down (what is init first gets deinit last)
  std::atexit([]() {
    Project::Deinit();
    Reg::Deinit();
    Args::Deinit();
    Storage::Clear();
  });
 }

 void Reg::Init() {
  if (!instance_) {
    instance_ = std::make_unique<Instance>();
    env::assert_fatal(static_cast<bool>(instance_), "Reg::Init failed");
    env::assert_fatal(Args::IsParsed(), "Setup your Args");
    Project::Init(fs::current_path() / Args::GetProjectRootDir(),
              fs::current_path() / Args::GetProjectBuildDir());
 env::set_log_level(Args::GetLogLevel());

 // Initialize everything else here
 SystemInit();
  }
 }

diff --git a/buildcc/lib/env/include/env/storage.h b/buildcc/lib/env/include/env/storage.h
 class ScopedStorage {
 public:
  ScopedStorage() {}
  ~ScopedStorage() {
    for (const auto &ptr_iter : ptrs_) {
      ptr_iter.second.destructor();
    }
    ptrs_.clear();
    env::assert_fatal(ptrs_.empty(), "Memory not deallocated");
  }
  ~ScopedStorage() { Clear(); }

  ScopedStorage(const ScopedStorage &) = delete;

    return *ptr;
  }

  template <typename T> void Remove(T *ptr) { delete ptr; }
  void Clear() {
    for (const auto &ptr_iter : ptrs_) {
      ptr_iter.second.destructor();
    }
    ptrs_.clear();
  }

  template <typename T> const T &ConstRef(const std::string &identifier) const {
    env::assert_fatal(ptrs_.find(identifier) != ptrs_.end(),
    env::assert_fatal(Contains(identifier),
                      fmt::format("Could not find '{}'", identifier));
    const PtrMetadata &metadata = ptrs_.at(identifier);
    env::assert_fatal(
        static_cast<const ScopedStorage &>(*this).ConstRef<T>(identifier));
  }

  bool Contains(const std::string &identifier) const {
    return (ptrs_.find(identifier) != ptrs_.end());
  }

  template <typename T> bool Valid(const std::string &identifier) const {
    if (!Contains(identifier)) {
      return false;
    }
    const PtrMetadata &metadata = ptrs_.at(identifier);
    if (typeid(T).name() != metadata.typeid_name) {
      return false;
    }
    return true;
  }

 protected:
  template <typename T> void Remove(T *ptr) { delete ptr; }

 private:
  /**
   * @brief
   * @param ptr Can hold data of any type
   * @param typeid_name We cannot store a template type so this is the next best
   * thing
   * @param typeid_name We cannot store a template type so this is the next
   *bestthing
   * @param desstructor Destructor callback to delete ptr
   */
  struct PtrMetadata {
  Storage(const Storage &) = delete;
  Storage(Storage &&) = delete;

  static void Init() { internal_ = std::make_unique<ScopedStorage>(); }
  static void Deinit() { internal_.reset(nullptr); }

  template <typename T, typename... Params>
  static T &Add(const std::string &identifier, Params &&...params) {
    return Ref().Add<T, Params...>(identifier, std::forward<Params>(params)...);
  }

  static void Clear() { Ref().Clear(); }

  template <typename T>
  static const T &ConstRef(const std::string &identifier) {
    return Ref().ConstRef<T>(identifier);
    return Ref().Ref<T>(identifier);
  }

  static bool Contains(const std::string &identifier) {
    return Ref().Contains(identifier);
  }

  template <typename T> static bool Valid(const std::string &identifier) {
    return Ref().Valid<T>(identifier);
  }

 private:
  static ScopedStorage &Ref();

 private:
  staticstd::unique_ptr<ScopedStorage> internal_;
  static ScopedStorage internal_;
 };

 } // namespace buildcc
diff --git a/buildcc/lib/env/src/storage.cpp b/buildcc/lib/env/src/storage.cpp

 namespace buildcc {

 std::unique_ptr<ScopedStorage> Storage::internal_;
 ScopedStorage Storage::internal_;

 ScopedStorage &Storage::Ref() {
  env::assert_fatal(internal_ != nullptr,
                    "Initialize Storage using the Storage::Init API");
  return *internal_;
 }
 ScopedStorage &Storage::Ref() { return internal_; }

 } // namespace buildcc
diff --git a/buildcc/lib/env/test/test_storage.cpp b/buildcc/lib/env/test/test_storage.cpp
 TEST_GROUP(StorageTestGroup)
 {
  void setup() {
 buildcc::Storage::Init();
 MemoryLeakWarningPlugin::saveAndDisableNewDeleteOverloads();
  }
  void teardown() {
    buildcc::Storage::Deinit();
    buildcc::Storage::Clear();
    MemoryLeakWarningPlugin::restoreNewDeleteOverloads();
  }
 };
 // clang-format on

 class MyScopedStorage : public buildcc::ScopedStorage {
 public:
  // We want to unit test this
  template <typename T> void Remove(T *ptr) {
    this->ScopedStorage::Remove<T>(ptr);
  }
 };

 class BigObj {};

 class BigObjWithParameters {
 static BigObj obj;

 TEST(ScopedStorageTestGroup, BasicUsage) {
 buildcc::ScopedStorage storage;
 MyScopedStorage storage;
  storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);
  storage.Add<BigObjWithParameters>("identifier2", "name2", 12, obj);

  // Usage
  storage.ConstRef<BigObjWithParameters>("identifier").GetName();
  storage.Ref<BigObjWithParameters>("identifier2").GetName();

  CHECK_TRUE(storage.Contains("identifier"));
  CHECK_FALSE(storage.Contains("identifier_does_not_exist"));

  CHECK_TRUE(storage.Valid<BigObjWithParameters>("identifier"));
  CHECK_FALSE(storage.Valid<BigObjWithParameters>("wrong_identifier"));
  CHECK_FALSE(storage.Valid<int>("identifier"));

  storage.Clear();
  CHECK_FALSE(storage.Contains("identifier"));

  // Automatic cleanup here
 }

 TEST(ScopedStorageTestGroup, IncorrectUsage) {
 buildcc::ScopedStorage storage;
 MyScopedStorage storage;
  storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);

  // We try to cast to a different type!
               storage.Ref<BigObjWithParameters>("identifier2"));
 }

 std::string &toReference(std::string *pointer) { return *pointer; }

 TEST(ScopedStorageTestGroup, NullptrDelete) {
 buildcc::ScopedStorage storage;
 MyScopedStorage storage;
  storage.Remove<std::string>(nullptr);
 }

 //

 TEST(StorageTestGroup, BasicUsage) {
  buildcc::Storage::Add<BigObjWithParameters>("identifier", "name", 10, obj);
  buildcc::Storage::Add<BigObjWithParameters>("identifier2", "name2", 12, obj);

  STRCMP_EQUAL(bigobj.c_str(), "name");
  STRCMP_EQUAL(bigobj2.c_str(), "name2");
 }

 TEST(StorageTestGroup, UsageWithoutInit) {
  buildcc::Storage::Deinit();
  CHECK_TRUE(buildcc::Storage::Contains("identifier"));
 CHECK_FALSE(buildcc::Storage::Contains("identifier_does_not_exist"));

  CHECK_THROWS(std::exception, buildcc::Storage::Add<int>("integer"));
  CHECK_THROWS(std::exception, buildcc::Storage::Ref<int>("integer"));
  CHECK_THROWS(std::exception, buildcc::Storage::ConstRef<int>("integer"));
  CHECK_TRUE(buildcc::Storage::Valid<BigObjWithParameters>("identifier"));
  CHECK_FALSE(
      buildcc::Storage::Valid<BigObjWithParameters>("wrong_identifier"));
  CHECK_FALSE(buildcc::Storage::Valid<BigObj>("identifier"));
 }

 int main(int ac, char **av) {
diff --git a/buildcc/lib/target/src/target_info/target_info.cpp b/buildcc/lib/target/src/target_info/target_info.cpp
 // PRIVATE

 void TargetInfo::Initialize() {
  toolchain_.GetLockInfo().ExpectsLock(
      "Toolchain should be locked before usage through `Toolchain::Lock`");
  // TODO, Update this later
  // toolchain_.GetLockInfo().ExpectsLock(
  //     "Toolchain should be locked before usage through `Toolchain::Lock`");

  std::for_each(toolchain_.GetPreprocessorFlags().begin(),
                toolchain_.GetPreprocessorFlags().end(),
diff --git a/buildcc/lib/target/test/target/test_toolchain_flag_api.cpp b/buildcc/lib/target/test/target/test_toolchain_flag_api.cpp
 TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Lock) {
  buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
                               "g++", "ar", "ld");
  toolchain.Lock();
  CHECK_THROWS(std::exception, toolchain.AddPreprocessorFlag("-preprocessor"));
  CHECK_THROWS(std::exception, toolchain.AddAsmCompileFlag("-asm"));
  CHECK_THROWS(std::exception, toolchain.AddPchCompileFlag("-pchcompile"));

 TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Unlock) {
  buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
                               "g++", "ar", "ld", false);
                               "g++", "ar", "ld");
  toolchain.AddPreprocessorFlag("-preprocessor");
  toolchain.AddAsmCompileFlag("-asm");
  toolchain.AddPchCompileFlag("-pchcompile");

 TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
  buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
                               "g++", "ar", "ld", false);
                               "g++", "ar", "ld");

  toolchain.AddPreprocessorFlag("-preprocessor");
  toolchain.AddAsmCompileFlag("-asm");
  toolchain.AddLinkFlag("-link");

  CHECK_FALSE(toolchain.GetLockInfo().IsLocked());
  { CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }
  // TODO, Add this in later
  // * We should lock our toolchain before using it
  // { CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }

  toolchain.Lock();
  CHECK_TRUE(toolchain.GetLockInfo().IsLocked());
Original file line number	Diff line number	Diff line change
Expand Up		@@ -41,7 +41,8 @@ int main(int argc, char **argv) {
		Reg::Init();
		Reg::Call(Args::Clean()).Func(clean_cb);

		BaseToolchain toolchain = custom_toolchain_arg.ConstructToolchain();
		auto &toolchain = custom_toolchain_arg;
		toolchain.SetToolchainInfoFunc(GlobalToolchainInfo::Get(toolchain.id));

		BuildBuildCC buildcc(
		toolchain, TargetEnv(Project::GetRootDir(), Project::GetBuildDir()));
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -90,6 +90,7 @@ void buildcc_cb(BaseTarget &target, const BaseGenerator &schema_gen,
		target.GlobHeaders("lib/args/include/args");

		// Specialized Toolchains
		target.GlobSources("toolchains/src");
		target.AddIncludeDir("toolchains/include");
		target.GlobHeaders("toolchains/include/toolchains");

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -39,6 +39,10 @@
		#include "toolchains/toolchain_gcc.h"
		#include "toolchains/toolchain_msvc.h"
		#include "toolchains/toolchain_mingw.h"
		#include "toolchains/toolchain_generic.h"
		#include "toolchains/toolchain_custom.h"

		#include "toolchains/toolchain_infos.h"

		// TODO, Add more specialized toolchains here

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -47,35 +47,31 @@ struct ArgToolchainState {
		* command line
		* Bundled with Toolchain State
		*/
		struct ArgToolchain {
		ArgToolchain() = default;
		class ArgToolchain : public Toolchain {
		public:
		ArgToolchain()
		: Toolchain(ToolchainId::Undefined, "", ToolchainExecutables()){};
		ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
		const ToolchainExecutables &initial_executables)
		: id(initial_id), name(initial_name), executables(initial_executables) {}
		ArgToolchain(ToolchainId initial_id, const std::string &initial_name,
		const std::string &initial_assembler,
		const std::string &initial_c_compiler,
		const std::string &initial_cpp_compiler,
		const std::string &initial_archiver,
		const std::string &initial_linker)
		: ArgToolchain(initial_id, initial_name,
		ToolchainExecutables(initial_assembler, initial_c_compiler,
		initial_cpp_compiler,
		initial_archiver, initial_linker)) {}

		/**
		* @brief Construct a BaseToolchain from the arguments supplied through the
		* command line information
		*/
		// TODO, Update this for lock and ToolchainConfig
		BaseToolchain ConstructToolchain() const {
		return BaseToolchain(id, name, executables);
		}
		: Toolchain(initial_id, initial_name, initial_executables) {}
		[[deprecated]] ArgToolchain(ToolchainId initial_id,
		const std::string &initial_name,
		const std::string &initial_assembler,
		const std::string &initial_c_compiler,
		const std::string &initial_cpp_compiler,
		const std::string &initial_archiver,
		const std::string &initial_linker)
		: Toolchain(initial_id, initial_name,
		ToolchainExecutables(initial_assembler, initial_c_compiler,
		initial_cpp_compiler, initial_archiver,
		initial_linker)) {}

		public:
		ArgToolchainState state;
		ToolchainId id{ToolchainId::Undefined};
		std::string name{""};
		ToolchainExecutables executables;
		ToolchainId &id = RefId();
		std::string &name = RefName();
		ToolchainExecutables &executables = RefExecutables();
		ToolchainConfig &config = RefConfig();
		};

		// NOTE, Incomplete without pch_compile_command
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -23,6 +23,7 @@

		#include "env/assert_fatal.h"
		#include "env/env.h"
		#include "env/storage.h"

		namespace fs = std::filesystem;

Expand DownExpand Up		@@ -67,13 +68,28 @@ namespace buildcc {

		std::unique_ptr<Reg::Instance> Reg::instance_;

		void SystemInit() {
		Project::Init(fs::current_path() / Args::GetProjectRootDir(),
		fs::current_path() / Args::GetProjectBuildDir());
		env::set_log_level(Args::GetLogLevel());

		// Top down (what is init first gets deinit last)
		std::atexit([]() {
		Project::Deinit();
		Reg::Deinit();
		Args::Deinit();
		Storage::Clear();
		});
		}

		void Reg::Init() {
		if (!instance_) {
		instance_ = std::make_unique<Instance>();
		env::assert_fatal(static_cast<bool>(instance_), "Reg::Init failed");
		env::assert_fatal(Args::IsParsed(), "Setup your Args");
		Project::Init(fs::current_path() / Args::GetProjectRootDir(),
		fs::current_path() / Args::GetProjectBuildDir());
		env::set_log_level(Args::GetLogLevel());

		// Initialize everything else here
		SystemInit();
		}
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -32,13 +32,7 @@ namespace buildcc {
		class ScopedStorage {
		public:
		ScopedStorage() {}
		~ScopedStorage() {
		for (const auto &ptr_iter : ptrs_) {
		ptr_iter.second.destructor();
		}
		ptrs_.clear();
		env::assert_fatal(ptrs_.empty(), "Memory not deallocated");
		}
		~ScopedStorage() { Clear(); }

		ScopedStorage(const ScopedStorage &) = delete;

Expand All		@@ -58,10 +52,15 @@ class ScopedStorage {
		return *ptr;
		}

		template <typename T> void Remove(T *ptr) { delete ptr; }
		void Clear() {
		for (const auto &ptr_iter : ptrs_) {
		ptr_iter.second.destructor();
		}
		ptrs_.clear();
		}

		template <typename T> const T &ConstRef(const std::string &identifier) const {
		env::assert_fatal(ptrs_.find(identifier) != ptrs_.end(),
		env::assert_fatal(Contains(identifier),
		fmt::format("Could not find '{}'", identifier));
		const PtrMetadata &metadata = ptrs_.at(identifier);
		env::assert_fatal(
Expand All		@@ -77,12 +76,30 @@ class ScopedStorage {
		static_cast<const ScopedStorage &>(*this).ConstRef<T>(identifier));
		}

		bool Contains(const std::string &identifier) const {
		return (ptrs_.find(identifier) != ptrs_.end());
		}

		template <typename T> bool Valid(const std::string &identifier) const {
		if (!Contains(identifier)) {
		return false;
		}
		const PtrMetadata &metadata = ptrs_.at(identifier);
		if (typeid(T).name() != metadata.typeid_name) {
		return false;
		}
		return true;
		}

		protected:
		template <typename T> void Remove(T *ptr) { delete ptr; }

		private:
		/**
		* @brief
		* @param ptr Can hold data of any type
		* @param typeid_name We cannot store a template type so this is the next best
		* thing
		* @param typeid_name We cannot store a template type so this is the next
		*bestthing
		* @param desstructor Destructor callback to delete ptr
		*/
		struct PtrMetadata {
Expand All		@@ -101,14 +118,13 @@ class Storage {
		Storage(const Storage &) = delete;
		Storage(Storage &&) = delete;

		static void Init() { internal_ = std::make_unique<ScopedStorage>(); }
		static void Deinit() { internal_.reset(nullptr); }

		template <typename T, typename... Params>
		static T &Add(const std::string &identifier, Params &&...params) {
		return Ref().Add<T, Params...>(identifier, std::forward<Params>(params)...);
		}

		static void Clear() { Ref().Clear(); }

		template <typename T>
		static const T &ConstRef(const std::string &identifier) {
		return Ref().ConstRef<T>(identifier);
Expand All		@@ -118,11 +134,19 @@ class Storage {
		return Ref().Ref<T>(identifier);
		}

		static bool Contains(const std::string &identifier) {
		return Ref().Contains(identifier);
		}

		template <typename T> static bool Valid(const std::string &identifier) {
		return Ref().Valid<T>(identifier);
		}

		private:
		static ScopedStorage &Ref();

		private:
		staticstd::unique_ptr<ScopedStorage> internal_;
		static ScopedStorage internal_;
		};

		} // namespace buildcc
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -18,12 +18,8 @@

		namespace buildcc {

		std::unique_ptr<ScopedStorage> Storage::internal_;
		ScopedStorage Storage::internal_;

		ScopedStorage &Storage::Ref() {
		env::assert_fatal(internal_ != nullptr,
		"Initialize Storage using the Storage::Init API");
		return *internal_;
		}
		ScopedStorage &Storage::Ref() { return internal_; }

		} // namespace buildcc
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,14 +15,23 @@ TEST_GROUP(ScopedStorageTestGroup)
		TEST_GROUP(StorageTestGroup)
		{
		void setup() {
		buildcc::Storage::Init();
		MemoryLeakWarningPlugin::saveAndDisableNewDeleteOverloads();
		}
		void teardown() {
		buildcc::Storage::Deinit();
		buildcc::Storage::Clear();
		MemoryLeakWarningPlugin::restoreNewDeleteOverloads();
		}
		};
		// clang-format on

		class MyScopedStorage : public buildcc::ScopedStorage {
		public:
		// We want to unit test this
		template <typename T> void Remove(T *ptr) {
		this->ScopedStorage::Remove<T>(ptr);
		}
		};

		class BigObj {};

		class BigObjWithParameters {
Expand All		@@ -42,19 +51,29 @@ class BigObjWithParameters {
		static BigObj obj;

		TEST(ScopedStorageTestGroup, BasicUsage) {
		buildcc::ScopedStorage storage;
		MyScopedStorage storage;
		storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);
		storage.Add<BigObjWithParameters>("identifier2", "name2", 12, obj);

		// Usage
		storage.ConstRef<BigObjWithParameters>("identifier").GetName();
		storage.Ref<BigObjWithParameters>("identifier2").GetName();

		CHECK_TRUE(storage.Contains("identifier"));
		CHECK_FALSE(storage.Contains("identifier_does_not_exist"));

		CHECK_TRUE(storage.Valid<BigObjWithParameters>("identifier"));
		CHECK_FALSE(storage.Valid<BigObjWithParameters>("wrong_identifier"));
		CHECK_FALSE(storage.Valid<int>("identifier"));

		storage.Clear();
		CHECK_FALSE(storage.Contains("identifier"));

		// Automatic cleanup here
		}

		TEST(ScopedStorageTestGroup, IncorrectUsage) {
		buildcc::ScopedStorage storage;
		MyScopedStorage storage;
		storage.Add<BigObjWithParameters>("identifier", "name", 10, obj);

		// We try to cast to a different type!
Expand All		@@ -65,13 +84,13 @@ TEST(ScopedStorageTestGroup, IncorrectUsage) {
		storage.Ref<BigObjWithParameters>("identifier2"));
		}

		std::string &toReference(std::string pointer) { return pointer; }

		TEST(ScopedStorageTestGroup, NullptrDelete) {
		buildcc::ScopedStorage storage;
		MyScopedStorage storage;
		storage.Remove<std::string>(nullptr);
		}

		//

		TEST(StorageTestGroup, BasicUsage) {
		buildcc::Storage::Add<BigObjWithParameters>("identifier", "name", 10, obj);
		buildcc::Storage::Add<BigObjWithParameters>("identifier2", "name2", 12, obj);
Expand All		@@ -84,14 +103,14 @@ TEST(StorageTestGroup, BasicUsage) {

		STRCMP_EQUAL(bigobj.c_str(), "name");
		STRCMP_EQUAL(bigobj2.c_str(), "name2");
		}

		TEST(StorageTestGroup, UsageWithoutInit) {
		buildcc::Storage::Deinit();
		CHECK_TRUE(buildcc::Storage::Contains("identifier"));
		CHECK_FALSE(buildcc::Storage::Contains("identifier_does_not_exist"));

		CHECK_THROWS(std::exception, buildcc::Storage::Add<int>("integer"));
		CHECK_THROWS(std::exception, buildcc::Storage::Ref<int>("integer"));
		CHECK_THROWS(std::exception, buildcc::Storage::ConstRef<int>("integer"));
		CHECK_TRUE(buildcc::Storage::Valid<BigObjWithParameters>("identifier"));
		CHECK_FALSE(
		buildcc::Storage::Valid<BigObjWithParameters>("wrong_identifier"));
		CHECK_FALSE(buildcc::Storage::Valid<BigObj>("identifier"));
		}

		int main(int ac, char **av) {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,8 +21,9 @@ namespace buildcc {
		// PRIVATE

		void TargetInfo::Initialize() {
		toolchain_.GetLockInfo().ExpectsLock(
		"Toolchain should be locked before usage through `Toolchain::Lock`");
		// TODO, Update this later
		// toolchain_.GetLockInfo().ExpectsLock(
		// "Toolchain should be locked before usage through `Toolchain::Lock`");

		std::for_each(toolchain_.GetPreprocessorFlags().begin(),
		toolchain_.GetPreprocessorFlags().end(),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -17,6 +17,7 @@ TEST_GROUP(ToolchainFlagApiTestGroup)
		TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Lock) {
		buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
		"g++", "ar", "ld");
		toolchain.Lock();
		CHECK_THROWS(std::exception, toolchain.AddPreprocessorFlag("-preprocessor"));
		CHECK_THROWS(std::exception, toolchain.AddAsmCompileFlag("-asm"));
		CHECK_THROWS(std::exception, toolchain.AddPchCompileFlag("-pchcompile"));
Expand All		@@ -29,7 +30,7 @@ TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Lock) {

		TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Unlock) {
		buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
		"g++", "ar", "ld", false);
		"g++", "ar", "ld");
		toolchain.AddPreprocessorFlag("-preprocessor");
		toolchain.AddAsmCompileFlag("-asm");
		toolchain.AddPchCompileFlag("-pchcompile");
Expand All		@@ -55,7 +56,7 @@ TEST(ToolchainFlagApiTestGroup, BasicToolchainTest_Unlock) {

		TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
		buildcc::Toolchain toolchain(buildcc::ToolchainId::Gcc, "gcc", "as", "gcc",
		"g++", "ar", "ld", false);
		"g++", "ar", "ld");

		toolchain.AddPreprocessorFlag("-preprocessor");
		toolchain.AddAsmCompileFlag("-asm");
Expand All		@@ -67,7 +68,9 @@ TEST(ToolchainFlagApiTestGroup, BasicTargetTest) {
		toolchain.AddLinkFlag("-link");

		CHECK_FALSE(toolchain.GetLockInfo().IsLocked());
		{ CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }
		// TODO, Add this in later
		// * We should lock our toolchain before using it
		// { CHECK_THROWS(std::exception, (buildcc::TargetInfo(toolchain, ""))); }

		toolchain.Lock();
		CHECK_TRUE(toolchain.GetLockInfo().IsLocked());
Expand Down