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

• Show log

  Commit

• Hash : cc34aa73
  Author :
  Date : 2022-12-19T14:03:27
  

  Move BinaryStream to common and expose ShaderState to compiler
  
  This is a refactor change in preparation for adding support for
  glShaderBinary.
  Move BinaryStream to common so that it is accessible by both libANGLE
  and the Compiler.
  Extract members that hold the result of compilation from ShaderState
  and move into new CompiledShaderState struct.
  Move helper functions & classes relevant to ShaderVar serialization to
  the CompiledShaderState header.
  
  Tests: EGLBlobCacheTest*
  Bug: angleproject:7833
  Change-Id: I7ec575247eccb3afbc6ab6bfa24d36e69d4576f5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4080998
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: mohan maiya <m.maiya@samsung.com>
  

Download

• src/common/BinaryStream_unittest.cpp

• //
  // Copyright 2015 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.
  //
  
  // BinaryStream_unittest.cpp: Unit tests of the binary stream classes.
  
  #include <gtest/gtest.h>
  
  #include "common/BinaryStream.h"
  
  namespace angle
  {
  
  // Test that errors are properly generated for overflows.
  TEST(BinaryInputStream, Overflow)
  {
      const uint8_t goodValue = 2;
      const uint8_t badValue  = 255;
  
      const size_t dataSize = 1024;
      const size_t slopSize = 1024;
  
      std::vector<uint8_t> data(dataSize + slopSize);
      std::fill(data.begin(), data.begin() + dataSize, goodValue);
      std::fill(data.begin() + dataSize, data.end(), badValue);
  
      std::vector<uint8_t> outputData(dataSize);
  
      auto checkDataIsSafe = [=](uint8_t item) { return item == goodValue; };
  
      {
          // One large read
          gl::BinaryInputStream stream(data.data(), dataSize);
          stream.readBytes(outputData.data(), dataSize);
          ASSERT_FALSE(stream.error());
          ASSERT_TRUE(std::all_of(outputData.begin(), outputData.end(), checkDataIsSafe));
          ASSERT_TRUE(stream.endOfStream());
      }
  
      {
          // Two half-sized reads
          gl::BinaryInputStream stream(data.data(), dataSize);
          stream.readBytes(outputData.data(), dataSize / 2);
          ASSERT_FALSE(stream.error());
          stream.readBytes(outputData.data() + dataSize / 2, dataSize / 2);
          ASSERT_FALSE(stream.error());
          ASSERT_TRUE(std::all_of(outputData.begin(), outputData.end(), checkDataIsSafe));
          ASSERT_TRUE(stream.endOfStream());
      }
  
      {
          // One large read that is too big
          gl::BinaryInputStream stream(data.data(), dataSize);
          stream.readBytes(outputData.data(), dataSize + 1);
          ASSERT_TRUE(stream.error());
      }
  
      {
          // Two reads, one that overflows the offset
          gl::BinaryInputStream stream(data.data(), dataSize);
          stream.readBytes(outputData.data(), dataSize - 1);
          ASSERT_FALSE(stream.error());
          stream.readBytes(outputData.data(), std::numeric_limits<size_t>::max() - dataSize - 2);
      }
  }
  
  // Test that readIntVector and writeIntVector match.
  TEST(BinaryStream, IntVector)
  {
      std::vector<unsigned int> writeData = {1, 2, 3, 4, 5};
      std::vector<unsigned int> readData;
  
      gl::BinaryOutputStream out;
      out.writeIntVector(writeData);
  
      gl::BinaryInputStream in(out.data(), out.length());
      in.readIntVector<unsigned int>(&readData);
  
      ASSERT_EQ(writeData.size(), readData.size());
  
      for (size_t i = 0; i < writeData.size(); ++i)
      {
          ASSERT_EQ(writeData[i], readData[i]);
      }
  }
  }  // namespace angle
  

Download