static void TestBitmapFactory(skiatest::Reporter* reporter) {
SkAutoTDelete<SkBitmap> bitmap(create_bitmap());
SkASSERT(bitmap.get() != NULL);
SkAutoDataUnref encodedBitmap(create_data_from_bitmap(*bitmap.get()));
bool encodeSucceeded = encodedBitmap.get() != NULL;
SkASSERT(encodeSucceeded);
ImageCacheHolder cacheHolder;
SkAutoTUnref<SkLruImageCache> lruCache(SkNEW_ARGS(SkLruImageCache, (1024 * 1024)));
cacheHolder.addImageCache(lruCache);
cacheHolder.addImageCache(NULL);
SkImageCache* purgeableCache = SkPurgeableImageCache::Create();
if (purgeableCache != NULL) {
cacheHolder.addImageCache(purgeableCache);
purgeableCache->unref();
}
for (int i = 0; i < cacheHolder.count(); i++) {
SkImageCache* cache = cacheHolder.getAt(i);
if (cache != NULL) {
test_cache(reporter, cache);
}
if (encodeSucceeded) {
test_factory(reporter, cache, encodedBitmap, *bitmap.get());
}
}
}
DEF_TEST(ImageCache, reporter) {
static const size_t defLimit = DIM * DIM * 4 * COUNT + 1024; // 1K slop
{
SkScaledImageCache cache(defLimit);
test_cache(reporter, cache, true);
}
{
SkDiscardableMemoryPool pool(defLimit);
gPool = &pool;
SkScaledImageCache cache(pool_factory);
test_cache(reporter, cache, true);
}
{
SkScaledImageCache cache(SkDiscardableMemory::Create);
test_cache(reporter, cache, false);
}
}
void YCTest::test()
{
//test_md5();
//test_encrypt_file();
//test_npctalk();
//test_forward();
//test_packfile();
//test_encrypt();
//test_compress();
//test_compress2();
test_cache();
}
DEF_TEST(ImageCache, reporter) {
static const size_t defLimit = DIM * DIM * 4 * COUNT + 1024; // 1K slop
{
SkResourceCache cache(defLimit);
test_cache(reporter, cache, true);
}
{
SkAutoTUnref<SkDiscardableMemoryPool> pool(
SkDiscardableMemoryPool::Create(defLimit, NULL));
gPool = pool.get();
SkResourceCache cache(pool_factory);
test_cache(reporter, cache, true);
}
{
SkResourceCache cache(SkDiscardableMemory::Create);
test_cache(reporter, cache, false);
}
{
SkResourceCache cache(defLimit);
test_cache_purge_shared_id(reporter, cache);
}
}
static void TestClipCache(skiatest::Reporter* reporter, GrContextFactory* factory) {
for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
if (!GrContextFactory::IsRenderingGLContext(glType)) {
continue;
}
GrContext* context = factory->get(glType);
if (NULL == context) {
continue;
}
test_cache(reporter, context);
test_clip_bounds(reporter, context);
}
}
int main(int argc, char *argv[])
{
struct etna_device *dev;
drmVersionPtr version;
int fd, ret = 0;
fd = open(argv[1], O_RDWR);
if (fd < 0)
return 1;
version = drmGetVersion(fd);
if (version) {
printf("Version: %d.%d.%d\n", version->version_major,
version->version_minor, version->version_patchlevel);
printf(" Name: %s\n", version->name);
printf(" Date: %s\n", version->date);
printf(" Description: %s\n", version->desc);
drmFreeVersion(version);
}
dev = etna_device_new(fd);
if (!dev) {
ret = 2;
goto out;
}
test_cache(dev);
test_size_rounding(dev);
etna_device_del(dev);
out:
close(fd);
return ret;
}
static void TestResourceCache(skiatest::Reporter* reporter, GrContextFactory* factory) {
for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
if (!GrContextFactory::IsRenderingGLContext(glType)) {
continue;
}
GrContext* context = factory->get(glType);
if (NULL == context) {
continue;
}
GrTextureDesc desc;
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fFlags = kRenderTarget_GrTextureFlagBit;
desc.fWidth = gWidth;
desc.fHeight = gHeight;
SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
SkAutoTUnref<SkGpuDevice> device(SkNEW_ARGS(SkGpuDevice, (context, texture.get())));
SkCanvas canvas(device.get());
test_cache(reporter, context, &canvas);
}
}
static void TestClipCache(skiatest::Reporter* reporter, GrContext* context) {
test_cache(reporter, context);
test_clip_bounds(reporter, context);
}
int main()
{
try {
std::cout << "Testing thread cache... "<< std::flush;
test_cache(cppcms::impl::thread_cache_factory(20));
std::cout << "Ok" << std::endl;
#ifndef CPPCMS_WIN32
std::cout << "Testing process cache... " << std::flush;
test_cache(cppcms::impl::process_cache_factory(16*1024));
std::cout << "Ok" << std::endl;
#endif
std::auto_ptr<cppcms::impl::tcp_cache_service> srv1,srv2;
{
try {
std::cout << "Testing cache over ip, single server... "<<std::flush;
std::vector<std::string> ips;
std::vector<int> ports;
ips.push_back("127.0.0.1");
ports.push_back(6001);
srv1.reset(new cppcms::impl::tcp_cache_service(cppcms::impl::thread_cache_factory(20),1,"127.0.0.1",6001));
test_cache(cppcms::impl::tcp_cache_factory(ips,ports,0),false);
std::cout << "Ok" << std::endl;
std::cout << "Testing cache over ip, single server with L1 cache... "<<std::flush;
test_cache(cppcms::impl::tcp_cache_factory(ips,ports,cppcms::impl::thread_cache_factory(5)),false);
std::cout << "Ok" << std::endl;
srv2.reset(new cppcms::impl::tcp_cache_service(cppcms::impl::thread_cache_factory(20),1,"127.0.0.1",6002));
ips.push_back("127.0.0.1");
ports.push_back(6002);
std::cout << "Testing cache over ip, multiple server... "<<std::flush;
test_cache(cppcms::impl::tcp_cache_factory(ips,ports,0),false);
std::cout << "Ok" << std::endl;
std::cout << "Testing cache over ip, multiple server with L1 cache... "<<std::flush;
test_cache(cppcms::impl::tcp_cache_factory(ips,ports,cppcms::impl::thread_cache_factory(5)),false);
std::cout << "Ok" <<std::endl;
ips.resize(1);
ports.resize(1);
std::cout << "Testing two clients... "<<std::flush;
test_two_clients(
cppcms::impl::tcp_cache_factory(ips,ports,cppcms::impl::thread_cache_factory(5)),
cppcms::impl::tcp_cache_factory(ips,ports,cppcms::impl::thread_cache_factory(5)));
std::cout << "Ok" <<std::endl;
std::cout << "Testing two clients with L1 cache... "<<std::flush;
test_two_clients(
cppcms::impl::tcp_cache_factory(ips,ports,0),
cppcms::impl::tcp_cache_factory(ips,ports,0));
std::cout << "Ok" <<std::endl;
}
catch(...) {
if(srv1.get()) {
srv1->stop();
srv1.reset();
}
if(srv2.get()) {
srv2->stop();
srv2.reset();
}
throw;
}
srv1->stop();
srv2->stop();
}
}
catch(std::exception const &e) {
std::cerr << "\nFail " << e.what() << std::endl;
return 1;
}
return 0;
}
void test_all(uint p) {
test_euclid(p);
test_table(p);
test_cache(p);
}
