opengl/tests/EGLTest/egl_cache_test.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "EGL_test"
 // #define LOG_NDEBUG 0

 #include <gtest/gtest.h>

 #include <utils/Log.h>

 #include <android-base/test_utils.h>

 #include "egl_cache.h"
 #include "MultifileBlobCache.h"
 #include "egl_display.h"

 #include <fstream>
 #include <memory>

 using namespace std::literals;

 namespace android {

 class EGLCacheTest : public ::testing::TestWithParam<egl_cache_t::EGLCacheMode> {
 protected:
     virtual void SetUp() {
         // Terminate to clean up any previous cache in this process
         mCache->terminate();

         mTempFile.reset(new TemporaryFile());
         mCache->setCacheFilename(&mTempFile->path[0]);
         mCache->setCacheLimit(1024);
         mCache->setCacheMode(mCacheMode);
     }

     virtual void TearDown() {
         mCache->terminate();
         mCache->setCacheFilename("");
         mTempFile.reset(nullptr);
     }

     std::string getCachefileName();

     egl_cache_t* mCache = egl_cache_t::get();
     std::unique_ptr<TemporaryFile> mTempFile;
     egl_cache_t::EGLCacheMode mCacheMode = GetParam();
 };

 TEST_P(EGLCacheTest, UninitializedCacheAlwaysMisses) {
     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->setBlob("abcd", 4, "efgh", 4);
     ASSERT_EQ(0, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ(0xee, buf[0]);
     ASSERT_EQ(0xee, buf[1]);
     ASSERT_EQ(0xee, buf[2]);
     ASSERT_EQ(0xee, buf[3]);
 }

 TEST_P(EGLCacheTest, InitializedCacheAlwaysHits) {
     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     mCache->setBlob("abcd", 4, "efgh", 4);
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);
 }

 TEST_P(EGLCacheTest, TerminatedCacheAlwaysMisses) {
     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     mCache->setBlob("abcd", 4, "efgh", 4);
     mCache->terminate();
     ASSERT_EQ(0, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ(0xee, buf[0]);
     ASSERT_EQ(0xee, buf[1]);
     ASSERT_EQ(0xee, buf[2]);
     ASSERT_EQ(0xee, buf[3]);
 }

 TEST_P(EGLCacheTest, ReinitializedCacheContainsValues) {
     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     mCache->setBlob("abcd", 4, "efgh", 4);
     mCache->terminate();
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);
 }

 std::string EGLCacheTest::getCachefileName() {
     // Return the monolithic filename unless we find the multifile dir
     std::string cachePath = &mTempFile->path[0];
     std::string multifileDirName = cachePath + ".multifile";
     std::string cachefileName = "";

     struct stat info;
     if (stat(multifileDirName.c_str(), &info) == 0) {
         // Ensure we only have one file to manage
         int entryFileCount = 0;

         // We have a multifile dir. Return the only entry file in it.
         DIR* dir;
         struct dirent* entry;
         if ((dir = opendir(multifileDirName.c_str())) != nullptr) {
             while ((entry = readdir(dir)) != nullptr) {
                 if (entry->d_name == "."s || entry->d_name == ".."s ||
                     strcmp(entry->d_name, kMultifileBlobCacheStatusFile) == 0) {
                     continue;
                 }
                 cachefileName = multifileDirName + "/" + entry->d_name;
                 entryFileCount++;
             }
         } else {
             printf("Unable to open %s, error: %s\n",
                    multifileDirName.c_str(), std::strerror(errno));
         }

         if (entryFileCount != 1) {
             // If there was more than one real file in the directory, this
             // violates test assumptions
             cachefileName = "";
         }
     } else {
         printf("Unable to stat %s, error: %s\n",
                multifileDirName.c_str(), std::strerror(errno));
     }

     return cachefileName;
 }

 TEST_P(EGLCacheTest, ModifiedCacheBeginMisses) {
     // Skip if not in multifile mode
     if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
         GTEST_SKIP() << "Skipping test designed for multifile";
     }

     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     mCache->setBlob("abcd", 4, "efgh", 4);
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);

     // Ensure the cache file is written to disk
     mCache->terminate();

     // Depending on the cache mode, the file will be in different locations
     std::string cachefileName = getCachefileName();
     ASSERT_TRUE(cachefileName.length() > 0);

     // Stomp on the beginning of the cache file, breaking the key match
     const char* stomp = "BADF00D";
     std::fstream fs(cachefileName);
     fs.seekp(0, std::ios_base::beg);
     fs.write(stomp, strlen(stomp));
     fs.flush();
     fs.close();

     // Ensure no cache hit
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     uint8_t buf2[4] = { 0xee, 0xee, 0xee, 0xee };
     // getBlob may return junk for required size, but should not return a cache hit
     mCache->getBlob("abcd", 4, buf2, 4);
     ASSERT_EQ(0xee, buf2[0]);
     ASSERT_EQ(0xee, buf2[1]);
     ASSERT_EQ(0xee, buf2[2]);
     ASSERT_EQ(0xee, buf2[3]);
 }

 TEST_P(EGLCacheTest, ModifiedCacheEndMisses) {
     // Skip if not in multifile mode
     if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
         GTEST_SKIP() << "Skipping test designed for multifile";
     }

     uint8_t buf[16] = { 0xee, 0xee, 0xee, 0xee,
                         0xee, 0xee, 0xee, 0xee,
                         0xee, 0xee, 0xee, 0xee,
                         0xee, 0xee, 0xee, 0xee };

     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     mCache->setBlob("abcdefghij", 10, "klmnopqrstuvwxyz", 16);
     ASSERT_EQ(16, mCache->getBlob("abcdefghij", 10, buf, 16));
     ASSERT_EQ('w', buf[12]);
     ASSERT_EQ('x', buf[13]);
     ASSERT_EQ('y', buf[14]);
     ASSERT_EQ('z', buf[15]);

     // Ensure the cache file is written to disk
     mCache->terminate();

     // Depending on the cache mode, the file will be in different locations
     std::string cachefileName = getCachefileName();
     ASSERT_TRUE(cachefileName.length() > 0);

     // Stomp on the END of the cache file, modifying its contents
     const char* stomp = "BADF00D";
     std::fstream fs(cachefileName);
     fs.seekp(-strlen(stomp), std::ios_base::end);
     fs.write(stomp, strlen(stomp));
     fs.flush();
     fs.close();

     // Ensure no cache hit
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
     uint8_t buf2[16] = { 0xee, 0xee, 0xee, 0xee,
                          0xee, 0xee, 0xee, 0xee,
                          0xee, 0xee, 0xee, 0xee,
                          0xee, 0xee, 0xee, 0xee };

     // getBlob may return junk for required size, but should not return a cache hit
     mCache->getBlob("abcdefghij", 10, buf2, 16);
     ASSERT_EQ(0xee, buf2[0]);
     ASSERT_EQ(0xee, buf2[1]);
     ASSERT_EQ(0xee, buf2[2]);
     ASSERT_EQ(0xee, buf2[3]);
 }

 TEST_P(EGLCacheTest, TerminatedCacheBelowCacheLimit) {
     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     mCache->setBlob("abcd", 4, "efgh", 4);
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);

     mCache->setBlob("ijkl", 4, "mnop", 4);
     ASSERT_EQ(4, mCache->getBlob("ijkl", 4, buf, 4));
     ASSERT_EQ('m', buf[0]);
     ASSERT_EQ('n', buf[1]);
     ASSERT_EQ('o', buf[2]);
     ASSERT_EQ('p', buf[3]);

     mCache->setBlob("qrst", 4, "uvwx", 4);
     ASSERT_EQ(4, mCache->getBlob("qrst", 4, buf, 4));
     ASSERT_EQ('u', buf[0]);
     ASSERT_EQ('v', buf[1]);
     ASSERT_EQ('w', buf[2]);
     ASSERT_EQ('x', buf[3]);

     // Cache should contain both the key and the value
     // So 8 bytes per entry, at least 24 bytes
     ASSERT_GE(mCache->getCacheSize(), 24);

     // Set the new limit and initialize cache
     mCache->terminate();
     mCache->setCacheLimit(4);
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     // Ensure the new limit is respected
     ASSERT_LE(mCache->getCacheSize(), 4);
 }

 TEST_P(EGLCacheTest, TrimCacheOnOverflow) {
     // Skip if not in multifile mode
     if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
         GTEST_SKIP() << "Skipping test designed for multifile";
     }

     uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     // Set one value in the cache
     mCache->setBlob("abcd", 4, "efgh", 4);
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);

     // Get the size of cache with a single entry
     size_t cacheEntrySize = mCache->getCacheSize();

     // Now reinitialize the cache, using max size equal to a single entry
     mCache->terminate();
     mCache->setCacheLimit(cacheEntrySize);
     mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

     // Ensure our cache still has original value
     ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
     ASSERT_EQ('e', buf[0]);
     ASSERT_EQ('f', buf[1]);
     ASSERT_EQ('g', buf[2]);
     ASSERT_EQ('h', buf[3]);

     // Set another value, which should overflow the cache and trim
     mCache->setBlob("ijkl", 4, "mnop", 4);
     ASSERT_EQ(4, mCache->getBlob("ijkl", 4, buf, 4));
     ASSERT_EQ('m', buf[0]);
     ASSERT_EQ('n', buf[1]);
     ASSERT_EQ('o', buf[2]);
     ASSERT_EQ('p', buf[3]);

     // The cache should still be under the limit
     ASSERT_TRUE(mCache->getCacheSize() == cacheEntrySize);

     // And no cache hit on trimmed entry
     uint8_t buf2[4] = { 0xee, 0xee, 0xee, 0xee };
     mCache->getBlob("abcd", 4, buf2, 4);
     ASSERT_EQ(0xee, buf2[0]);
     ASSERT_EQ(0xee, buf2[1]);
     ASSERT_EQ(0xee, buf2[2]);
     ASSERT_EQ(0xee, buf2[3]);
 }

 INSTANTIATE_TEST_CASE_P(MonolithicCacheTests,
         EGLCacheTest, ::testing::Values(egl_cache_t::EGLCacheMode::Monolithic));
 INSTANTIATE_TEST_CASE_P(MultifileCacheTests,
         EGLCacheTest, ::testing::Values(egl_cache_t::EGLCacheMode::Multifile));
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "EGL_test"
	// #define LOG_NDEBUG 0

	#include <gtest/gtest.h>

	#include <utils/Log.h>

	#include <android-base/test_utils.h>

	#include "egl_cache.h"
	#include "MultifileBlobCache.h"
	#include "egl_display.h"

	#include <fstream>
	#include <memory>

	using namespace std::literals;

	namespace android {

	class EGLCacheTest : public ::testing::TestWithParam<egl_cache_t::EGLCacheMode> {
	protected:
	virtual void SetUp() {
	// Terminate to clean up any previous cache in this process
	mCache->terminate();

	mTempFile.reset(new TemporaryFile());
	mCache->setCacheFilename(&mTempFile->path[0]);
	mCache->setCacheLimit(1024);
	mCache->setCacheMode(mCacheMode);
	}

	virtual void TearDown() {
	mCache->terminate();
	mCache->setCacheFilename("");
	mTempFile.reset(nullptr);
	}

	std::string getCachefileName();

	egl_cache_t* mCache = egl_cache_t::get();
	std::unique_ptr<TemporaryFile> mTempFile;
	egl_cache_t::EGLCacheMode mCacheMode = GetParam();
	};

	TEST_P(EGLCacheTest, UninitializedCacheAlwaysMisses) {
	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->setBlob("abcd", 4, "efgh", 4);
	ASSERT_EQ(0, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ(0xee, buf[0]);
	ASSERT_EQ(0xee, buf[1]);
	ASSERT_EQ(0xee, buf[2]);
	ASSERT_EQ(0xee, buf[3]);
	}

	TEST_P(EGLCacheTest, InitializedCacheAlwaysHits) {
	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	mCache->setBlob("abcd", 4, "efgh", 4);
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);
	}

	TEST_P(EGLCacheTest, TerminatedCacheAlwaysMisses) {
	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	mCache->setBlob("abcd", 4, "efgh", 4);
	mCache->terminate();
	ASSERT_EQ(0, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ(0xee, buf[0]);
	ASSERT_EQ(0xee, buf[1]);
	ASSERT_EQ(0xee, buf[2]);
	ASSERT_EQ(0xee, buf[3]);
	}

	TEST_P(EGLCacheTest, ReinitializedCacheContainsValues) {
	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	mCache->setBlob("abcd", 4, "efgh", 4);
	mCache->terminate();
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);
	}

	std::string EGLCacheTest::getCachefileName() {
	// Return the monolithic filename unless we find the multifile dir
	std::string cachePath = &mTempFile->path[0];
	std::string multifileDirName = cachePath + ".multifile";
	std::string cachefileName = "";

	struct stat info;
	if (stat(multifileDirName.c_str(), &info) == 0) {
	// Ensure we only have one file to manage
	int entryFileCount = 0;

	// We have a multifile dir. Return the only entry file in it.
	DIR* dir;
	struct dirent* entry;
	if ((dir = opendir(multifileDirName.c_str())) != nullptr) {
	while ((entry = readdir(dir)) != nullptr) {
	if (entry->d_name == "."s \|\| entry->d_name == ".."s \|\|
	strcmp(entry->d_name, kMultifileBlobCacheStatusFile) == 0) {
	continue;
	}
	cachefileName = multifileDirName + "/" + entry->d_name;
	entryFileCount++;
	}
	} else {
	printf("Unable to open %s, error: %s\n",
	multifileDirName.c_str(), std::strerror(errno));
	}

	if (entryFileCount != 1) {
	// If there was more than one real file in the directory, this
	// violates test assumptions
	cachefileName = "";
	}
	} else {
	printf("Unable to stat %s, error: %s\n",
	multifileDirName.c_str(), std::strerror(errno));
	}

	return cachefileName;
	}

	TEST_P(EGLCacheTest, ModifiedCacheBeginMisses) {
	// Skip if not in multifile mode
	if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
	GTEST_SKIP() << "Skipping test designed for multifile";
	}

	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	mCache->setBlob("abcd", 4, "efgh", 4);
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);

	// Ensure the cache file is written to disk
	mCache->terminate();

	// Depending on the cache mode, the file will be in different locations
	std::string cachefileName = getCachefileName();
	ASSERT_TRUE(cachefileName.length() > 0);

	// Stomp on the beginning of the cache file, breaking the key match
	const char* stomp = "BADF00D";
	std::fstream fs(cachefileName);
	fs.seekp(0, std::ios_base::beg);
	fs.write(stomp, strlen(stomp));
	fs.flush();
	fs.close();

	// Ensure no cache hit
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	uint8_t buf2[4] = { 0xee, 0xee, 0xee, 0xee };
	// getBlob may return junk for required size, but should not return a cache hit
	mCache->getBlob("abcd", 4, buf2, 4);
	ASSERT_EQ(0xee, buf2[0]);
	ASSERT_EQ(0xee, buf2[1]);
	ASSERT_EQ(0xee, buf2[2]);
	ASSERT_EQ(0xee, buf2[3]);
	}

	TEST_P(EGLCacheTest, ModifiedCacheEndMisses) {
	// Skip if not in multifile mode
	if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
	GTEST_SKIP() << "Skipping test designed for multifile";
	}

	uint8_t buf[16] = { 0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee };

	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	mCache->setBlob("abcdefghij", 10, "klmnopqrstuvwxyz", 16);
	ASSERT_EQ(16, mCache->getBlob("abcdefghij", 10, buf, 16));
	ASSERT_EQ('w', buf[12]);
	ASSERT_EQ('x', buf[13]);
	ASSERT_EQ('y', buf[14]);
	ASSERT_EQ('z', buf[15]);

	// Ensure the cache file is written to disk
	mCache->terminate();

	// Depending on the cache mode, the file will be in different locations
	std::string cachefileName = getCachefileName();
	ASSERT_TRUE(cachefileName.length() > 0);

	// Stomp on the END of the cache file, modifying its contents
	const char* stomp = "BADF00D";
	std::fstream fs(cachefileName);
	fs.seekp(-strlen(stomp), std::ios_base::end);
	fs.write(stomp, strlen(stomp));
	fs.flush();
	fs.close();

	// Ensure no cache hit
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));
	uint8_t buf2[16] = { 0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee,
	0xee, 0xee, 0xee, 0xee };

	// getBlob may return junk for required size, but should not return a cache hit
	mCache->getBlob("abcdefghij", 10, buf2, 16);
	ASSERT_EQ(0xee, buf2[0]);
	ASSERT_EQ(0xee, buf2[1]);
	ASSERT_EQ(0xee, buf2[2]);
	ASSERT_EQ(0xee, buf2[3]);
	}

	TEST_P(EGLCacheTest, TerminatedCacheBelowCacheLimit) {
	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	mCache->setBlob("abcd", 4, "efgh", 4);
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);

	mCache->setBlob("ijkl", 4, "mnop", 4);
	ASSERT_EQ(4, mCache->getBlob("ijkl", 4, buf, 4));
	ASSERT_EQ('m', buf[0]);
	ASSERT_EQ('n', buf[1]);
	ASSERT_EQ('o', buf[2]);
	ASSERT_EQ('p', buf[3]);

	mCache->setBlob("qrst", 4, "uvwx", 4);
	ASSERT_EQ(4, mCache->getBlob("qrst", 4, buf, 4));
	ASSERT_EQ('u', buf[0]);
	ASSERT_EQ('v', buf[1]);
	ASSERT_EQ('w', buf[2]);
	ASSERT_EQ('x', buf[3]);

	// Cache should contain both the key and the value
	// So 8 bytes per entry, at least 24 bytes
	ASSERT_GE(mCache->getCacheSize(), 24);

	// Set the new limit and initialize cache
	mCache->terminate();
	mCache->setCacheLimit(4);
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	// Ensure the new limit is respected
	ASSERT_LE(mCache->getCacheSize(), 4);
	}

	TEST_P(EGLCacheTest, TrimCacheOnOverflow) {
	// Skip if not in multifile mode
	if (mCacheMode == egl_cache_t::EGLCacheMode::Monolithic) {
	GTEST_SKIP() << "Skipping test designed for multifile";
	}

	uint8_t buf[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	// Set one value in the cache
	mCache->setBlob("abcd", 4, "efgh", 4);
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);

	// Get the size of cache with a single entry
	size_t cacheEntrySize = mCache->getCacheSize();

	// Now reinitialize the cache, using max size equal to a single entry
	mCache->terminate();
	mCache->setCacheLimit(cacheEntrySize);
	mCache->initialize(egl_display_t::get(EGL_DEFAULT_DISPLAY));

	// Ensure our cache still has original value
	ASSERT_EQ(4, mCache->getBlob("abcd", 4, buf, 4));
	ASSERT_EQ('e', buf[0]);
	ASSERT_EQ('f', buf[1]);
	ASSERT_EQ('g', buf[2]);
	ASSERT_EQ('h', buf[3]);

	// Set another value, which should overflow the cache and trim
	mCache->setBlob("ijkl", 4, "mnop", 4);
	ASSERT_EQ(4, mCache->getBlob("ijkl", 4, buf, 4));
	ASSERT_EQ('m', buf[0]);
	ASSERT_EQ('n', buf[1]);
	ASSERT_EQ('o', buf[2]);
	ASSERT_EQ('p', buf[3]);

	// The cache should still be under the limit
	ASSERT_TRUE(mCache->getCacheSize() == cacheEntrySize);

	// And no cache hit on trimmed entry
	uint8_t buf2[4] = { 0xee, 0xee, 0xee, 0xee };
	mCache->getBlob("abcd", 4, buf2, 4);
	ASSERT_EQ(0xee, buf2[0]);
	ASSERT_EQ(0xee, buf2[1]);
	ASSERT_EQ(0xee, buf2[2]);
	ASSERT_EQ(0xee, buf2[3]);
	}

	INSTANTIATE_TEST_CASE_P(MonolithicCacheTests,
	EGLCacheTest, ::testing::Values(egl_cache_t::EGLCacheMode::Monolithic));
	INSTANTIATE_TEST_CASE_P(MultifileCacheTests,
	EGLCacheTest, ::testing::Values(egl_cache_t::EGLCacheMode::Multifile));
	}