kc3-lang/angle/src/common/vector_utils_unittest.cpp

• Show log

  Commit

• Hash : 922cbfcb
  Author :
  Date : 2016-11-25T16:23:18
  

  common: Add a vector arithmetic helper classes
  
  Change-Id: I2f96baedf10d346eaa150bab04f8f6ca3ba573b9
  Reviewed-on: https://chromium-review.googlesource.com/414272
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/common/vector_utils_unittest.cpp

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // vector_utils_unittests.cpp: Unit tests for the vector utils.
  //
  
  #include "vector_utils.h"
  
  #include <gtest/gtest.h>
  
  using namespace angle;
  
  namespace
  {
  
  // First test that comparing vectors work
  TEST(VectorUtilsTest, Comparison)
  {
      // Don't use ASSERT_EQ at first because the == is more hidden
      ASSERT_TRUE(Vector2(2.0, 3.0) == Vector2(2.0, 3.0));
      ASSERT_TRUE(Vector2(2.0, 3.0) != Vector2(2.0, 4.0));
  
      // Check ASSERT_EQ and ASSERT_NE work correctly
      ASSERT_EQ(Vector2(2.0, 3.0), Vector2(2.0, 3.0));
      ASSERT_NE(Vector2(2.0, 3.0), Vector2(2.0, 4.0));
  
      // Check comparison works on all elements
      ASSERT_EQ(Vector4(0.0), Vector4(0.0));
      ASSERT_NE(Vector4(1.0, 0.0, 0.0, 0.0), Vector4(0.0));
      ASSERT_NE(Vector4(0.0, 1.0, 0.0, 0.0), Vector4(0.0));
      ASSERT_NE(Vector4(0.0, 0.0, 1.0, 0.0), Vector4(0.0));
      ASSERT_NE(Vector4(0.0, 0.0, 0.0, 1.0), Vector4(0.0));
  }
  
  // Test indexing
  TEST(VectorUtilsTest, Indexing)
  {
      Vector2 vec(1.0, 2.0);
      ASSERT_EQ(1.0, vec[0]);
      ASSERT_EQ(2.0, vec[1]);
  
      vec[0] = 3.0;
      vec[1] = 4.0;
      ASSERT_EQ(Vector2(3.0, 4.0), vec);
  }
  
  // Test for the various constructors
  TEST(VectorUtilsTest, Constructors)
  {
      // Constructor initializing all to a single element
      {
          Vector2 vec(3.0);
          ASSERT_EQ(3.0, vec[0]);
          ASSERT_EQ(3.0, vec[1]);
      }
  
      // Constructor initializing from another Vector
      {
          Vector2 vec(Vector2(1.0, 2.0));
          ASSERT_EQ(1.0, vec[0]);
          ASSERT_EQ(2.0, vec[1]);
      }
  
      // Mixed constructor
      {
          Vector4 vec(1.0, Vector2(2.0, 3.0), 4.0);
          ASSERT_EQ(1.0, vec[0]);
          ASSERT_EQ(2.0, vec[1]);
          ASSERT_EQ(3.0, vec[2]);
          ASSERT_EQ(4.0, vec[3]);
      }
  }
  
  // Test accessing the data directly
  TEST(VectorUtilsTest, DataAccess)
  {
      Vector2 vec(1.0, 2.0);
      ASSERT_EQ(2u, vec.size());
  
      ASSERT_EQ(1.0, vec.data()[0]);
      ASSERT_EQ(2.0, vec.data()[1]);
  
      vec.data()[0] = 3.0;
      vec.data()[1] = 4.0;
  
      ASSERT_EQ(Vector2(3.0, 4.0), vec);
  }
  
  // Test accessing the data directly
  TEST(VectorUtilsTest, LoadStore)
  {
      float data[] = {1.0, 2.0};
  
      Vector2 vec = Vector2::Load(data);
  
      ASSERT_EQ(1.0, vec.data()[0]);
      ASSERT_EQ(2.0, vec.data()[1]);
  
      vec = Vector2(3.0, 4.0);
      Vector2::Store(vec, data);
  
      ASSERT_EQ(3.0, data[0]);
      ASSERT_EQ(4.0, data[1]);
  }
  
  // Test basic arithmetic operations
  TEST(VectorUtilsTest, BasicArithmetic)
  {
      ASSERT_EQ(Vector2(2.0, 3.0), +Vector2(2.0, 3.0));
      ASSERT_EQ(Vector2(-2.0, -3.0), -Vector2(2.0, 3.0));
      ASSERT_EQ(Vector2(4.0, 6.0), Vector2(1.0, 2.0) + Vector2(3.0, 4.0));
      ASSERT_EQ(Vector2(-2.0, -2.0), Vector2(1.0, 2.0) - Vector2(3.0, 4.0));
      ASSERT_EQ(Vector2(3.0, 8.0), Vector2(1.0, 2.0) * Vector2(3.0, 4.0));
      ASSERT_EQ(Vector2(3.0, 2.0), Vector2(3.0, 4.0) / Vector2(1.0, 2.0));
  
      ASSERT_EQ(Vector2(2.0, 4.0), Vector2(1.0, 2.0) * 2);
      ASSERT_EQ(Vector2(2.0, 4.0), 2 * Vector2(1.0, 2.0));
      ASSERT_EQ(Vector2(0.5, 1.0), Vector2(1.0, 2.0) / 2);
  }
  
  // Test compound arithmetic operations
  TEST(VectorUtilsTest, CompoundArithmetic)
  {
      {
          Vector2 vec(1.0, 2.0);
          vec += Vector2(3.0, 4.0);
          ASSERT_EQ(Vector2(4.0, 6.0), vec);
      }
      {
          Vector2 vec(1.0, 2.0);
          vec -= Vector2(3.0, 4.0);
          ASSERT_EQ(Vector2(-2.0, -2.0), vec);
      }
      {
          Vector2 vec(1.0, 2.0);
          vec *= Vector2(3.0, 4.0);
          ASSERT_EQ(Vector2(3.0, 8.0), vec);
      }
      {
          Vector2 vec(3.0, 4.0);
          vec /= Vector2(1.0, 2.0);
          ASSERT_EQ(Vector2(3.0, 2.0), vec);
      }
      {
          Vector2 vec(1.0, 2.0);
          vec *= 2.0;
          ASSERT_EQ(Vector2(2.0, 4.0), vec);
      }
      {
          Vector2 vec(1.0, 2.0);
          vec /= 2.0;
          ASSERT_EQ(Vector2(0.5, 1.0), vec);
      }
  }
  
  // Test other arithmetic operations
  TEST(VectorUtilsTest, OtherArithmeticOperations)
  {
      Vector2 vec(3.0, 4.0);
  
      ASSERT_EQ(25.0, vec.lengthSquared());
      ASSERT_EQ(5.0, vec.length());
      ASSERT_EQ(Vector2(0.6, 0.8), vec.normalized());
  
      ASSERT_EQ(11.0, vec.dot(Vector2(1.0, 2.0)));
  }
  
  // Test element shortcuts
  TEST(VectorUtilsTest, ElementShortcuts)
  {
      Vector2 vec2(1.0, 2.0);
      Vector3 vec3(1.0, 2.0, 3.0);
      Vector4 vec4(1.0, 2.0, 3.0, 4.0);
  
      ASSERT_EQ(1.0, vec2.x());
      ASSERT_EQ(1.0, vec3.x());
      ASSERT_EQ(1.0, vec4.x());
  
      ASSERT_EQ(2.0, vec2.y());
      ASSERT_EQ(2.0, vec3.y());
      ASSERT_EQ(2.0, vec4.y());
  
      ASSERT_EQ(3.0, vec3.z());
      ASSERT_EQ(3.0, vec4.z());
  
      ASSERT_EQ(4.0, vec4.w());
  
      vec2.x() = 0.0;
      ASSERT_EQ(Vector2(0.0, 2.0), vec2);
  }
  
  // Test the cross product
  TEST(VectorUtilsTest, CrossProduct)
  {
      ASSERT_EQ(Vector3(0.0, 0.0, 1.0), Vector3(1.0, 0.0, 0.0).cross(Vector3(0.0, 1.0, 0.0)));
      ASSERT_EQ(Vector3(-3.0, 6.0, -3.0), Vector3(1.0, 2.0, 3.0).cross(Vector3(4.0, 5.0, 6.0)));
  }
  
  // Test basic functionality of int vectors
  TEST(VectorUtilsTest, IntVector)
  {
      Vector2I vec(0);
  
      int *data = vec.data();
      data[1]   = 1;
  
      ASSERT_EQ(0, vec[0]);
      ASSERT_EQ(1, vec[1]);
  }
  
  // Test basic functionality of int vectors
  TEST(VectorUtilsTest, UIntVector)
  {
      Vector2U vec(0);
  
      unsigned int *data = vec.data();
      data[1]            = 1;
  
      ASSERT_EQ(0u, vec[0]);
      ASSERT_EQ(1u, vec[1]);
  }
  
  }  // anonymous namespace
  

Download