Add tests for shader and shader_program

graphics/test/manager_test.cxx

@@ -48,6 +48,7 @@ template <typename T> identity<T> cast(unsigned int id) {
 }
 
 auto cast_p(unsigned int id) { return cast<graphics::shader_program>(id); }
+auto cast_s(unsigned int id) { return cast<graphics::shader>(id); }
 
 class ManagerTest : public testing::Test {
 public:
@@ -60,6 +61,20 @@ private:
     graphics::texture operator()(math::vec2i const & sz) { return {++i, sz}; }
     unsigned int i{0};
   } next_tex;
+  struct {
+    graphics::shader operator()(graphics::shaders::type tp,
+                                std::string const & path) {
+      return {++i, tp, path};
+    }
+    unsigned int i{0};
+  } next_shader;
+  struct {
+    graphics::shader_program operator()(identity<graphics::shader> f,
+                                        identity<graphics::shader> v) {
+      return {++i, f, v};
+    }
+    unsigned int i{0};
+  } next_program;
 };
 
 void ManagerTest::SetUp() {
@@ -68,6 +83,10 @@ void ManagerTest::SetUp() {
   // Start with a new set of IDs
   ON_CALL(mock, compile(_, _, _))
       .WillByDefault(WithArg<1>(Invoke(std::ref(next_tex))));
+  ON_CALL(mock, compile_shader(_, _))
+      .WillByDefault(Invoke(std::ref(next_shader)));
+  ON_CALL(mock, compile_program(_, _))
+      .WillByDefault(Invoke(std::ref(next_program)));
 }
 
 TEST_F(ManagerTest, DoesNotGreedilyCompile) {
@@ -91,8 +110,14 @@ TEST_F(MaterialTest, GeneratesUniformTexturesIfNoTexFile) {
 }
 
 TEST_F(MaterialTest, CreatedMaterialCanBeRefetched) {
-  using graphics::materials::uniform;
+  // Three times and no more
   EXPECT_CALL(mock, compile(_, make_vector(1, 1), _)).Times(3);
+  auto id_1 = mock.get(cast_p(1), "", "u_normalMap");
+  auto id_2 = mock.get(cast_p(1), "", "u_normalMap");
+  EXPECT_THAT(id_1, Eq(id_2));
+}
+
+TEST_F(MaterialTest, CanGetMaterialFromId) {
   auto material_id = mock.get(cast_p(1), "", "u_normalMap");
   auto material = mock.get(material_id);
   // Ensure that the material is the 'same one' i.e.
@@ -102,7 +127,6 @@ TEST_F(MaterialTest, CreatedMaterialCanBeRefetched) {
 
 TEST_F(MaterialTest, UniformMaterialIsOneByOne) {
   using graphics::materials::uniform;
-  EXPECT_CALL(mock, compile(_, make_vector(1, 1), _)).Times(3);
   auto material = mock.get(mock.get(cast_p(1), "", "u_normalMap"));
   // Uniforms are always sized 1x1
   EXPECT_THAT(material.size, Eq(make_vector(1, 1)));
@@ -110,7 +134,6 @@ TEST_F(MaterialTest, UniformMaterialIsOneByOne) {
 
 TEST_F(MaterialTest, UniformMaterialHasDataBindingToNormalTex) {
   using graphics::materials::uniform;
-  EXPECT_CALL(mock, compile(_, make_vector(1, 1), _)).Times(3);
   auto material = mock.get(mock.get(cast_p(1), "", "u_normalMap"));
   EXPECT_THAT(material.uniforms, SizeIs(1));
   // Because we never initialize any textures, we are within the first three
@@ -135,3 +158,41 @@ TEST_F(MaterialTest, DifferentProgramDoesntChangeUniformId) {
   auto mat_2 = mock.get(mock.get(cast_p(2), "", "u_normalMap"));
   EXPECT_THAT(mat_1.uniforms[0].texture, Eq(mat_2.uniforms[0].texture));
 }
+
+using ShaderTest = ManagerTest;
+TEST_F(ShaderTest, CanCreateShaders) {
+  using graphics::shaders::type;
+  EXPECT_CALL(mock, compile_shader(_, _)).Times(1);
+  EXPECT_NO_THROW(mock.get(type::FRAGMENT, "A"));
+}
+
+TEST_F(ShaderTest, CreatedShaderCanBeRefetched) {
+  using graphics::shaders::type;
+  EXPECT_CALL(mock, compile_shader(_, _)).Times(1);
+  auto id_1 = mock.get(type::FRAGMENT, "A");
+  auto id_2 = mock.get(type::FRAGMENT, "A");
+  EXPECT_THAT(id_1, Eq(id_2));
+}
+
+TEST_F(ShaderTest, DifferentTypeMakesDifferentShader) {
+  using graphics::shaders::type;
+  EXPECT_CALL(mock, compile_shader(_, _)).Times(2);
+  auto id_1 = mock.get(type::FRAGMENT, "A");
+  auto id_2 = mock.get(type::VERTEX, "A");
+  EXPECT_THAT(id_1, Ne(id_2));
+}
+
+using ShaderProgramTest = ManagerTest;
+TEST_F(ShaderProgramTest, CreatingProgramCreatesTwoShaders) {
+  EXPECT_CALL(mock, compile_shader(_, _)).Times(2);
+  EXPECT_CALL(mock, compile_program(cast_s(1), cast_s(2))).Times(1);
+  EXPECT_NO_THROW(mock.get("A", "B"));
+}
+
+TEST_F(ShaderProgramTest, CreatedProgramCanBeRefetched) {
+  EXPECT_CALL(mock, compile_shader(_, _)).Times(2);
+  EXPECT_CALL(mock, compile_program(cast_s(1), cast_s(2))).Times(1);
+  auto id_1 = mock.get("A", "B");
+  auto id_2 = mock.get("A", "B");
+  EXPECT_THAT(id_1, Eq(id_2));
+}