Exemplo n.º 1
0
static svn_error_t *
test_membuffer_cache_basic(apr_pool_t *pool)
{
  svn_cache__t *cache;
  svn_membuffer_t *membuffer;

  SVN_ERR(svn_cache__membuffer_cache_create(&membuffer, 10*1024, 1,
                                            TRUE, pool));

  /* Create a cache with just one entry. */
  SVN_ERR(svn_cache__create_membuffer_cache(&cache,
                                            membuffer,
                                            serialize_revnum,
                                            deserialize_revnum,
                                            APR_HASH_KEY_STRING,
                                            "cache:",
                                            FALSE,
                                            pool));

  return basic_cache_test(cache, FALSE, pool);
}
Exemplo n.º 2
0
static svn_error_t *
test_membuffer_cache_clearing(apr_pool_t *pool)
{
  svn_cache__t *cache;
  svn_membuffer_t *membuffer;
  svn_boolean_t found;
  svn_revnum_t *value;
  svn_revnum_t valueA = 12345;
  svn_revnum_t valueB = 67890;

  /* Create a simple cache for strings, keyed by strings. */
  SVN_ERR(svn_cache__membuffer_cache_create(&membuffer, 10*1024, 1, 0,
                                            TRUE, TRUE, pool));
  SVN_ERR(svn_cache__create_membuffer_cache(&cache,
                                            membuffer,
                                            serialize_revnum,
                                            deserialize_revnum,
                                            APR_HASH_KEY_STRING,
                                            "cache:",
                                            SVN_CACHE__MEMBUFFER_DEFAULT_PRIORITY,
                                            FALSE,
                                            pool, pool));

  /* Initially, the cache is empty. */
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key A", pool));
  SVN_TEST_ASSERT(!found);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key B", pool));
  SVN_TEST_ASSERT(!found);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key C", pool));
  SVN_TEST_ASSERT(!found);

  /* Add entries. */
  SVN_ERR(svn_cache__set(cache, "key A", &valueA, pool));
  SVN_ERR(svn_cache__set(cache, "key B", &valueB, pool));

  /* Added entries should be cached (too small to get evicted already). */
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key A", pool));
  SVN_TEST_ASSERT(found);
  SVN_TEST_ASSERT(*value == valueA);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key B", pool));
  SVN_TEST_ASSERT(found);
  SVN_TEST_ASSERT(*value == valueB);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key C", pool));
  SVN_TEST_ASSERT(!found);

  /* Clear the cache. */
  SVN_ERR(svn_cache__membuffer_clear(membuffer));

  /* The cache is empty again. */
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key A", pool));
  SVN_TEST_ASSERT(!found);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key B", pool));
  SVN_TEST_ASSERT(!found);
  SVN_ERR(svn_cache__get((void **) &value, &found, cache, "key C", pool));
  SVN_TEST_ASSERT(!found);

  /* But still functional: */
  SVN_ERR(svn_cache__set(cache, "key B", &valueB, pool));
  SVN_ERR(svn_cache__has_key(&found, cache, "key A", pool));
  SVN_TEST_ASSERT(!found);
  SVN_ERR(svn_cache__has_key(&found, cache, "key B", pool));
  SVN_TEST_ASSERT(found);
  SVN_ERR(svn_cache__has_key(&found, cache, "key C", pool));
  SVN_TEST_ASSERT(!found);

  return SVN_NO_ERROR;
}
Exemplo n.º 3
0
static svn_error_t *
test_membuffer_serializer_error_handling(apr_pool_t *pool)
{
  svn_cache__t *cache;
  svn_membuffer_t *membuffer;
  svn_revnum_t twenty = 20;
  svn_boolean_t found;
  void *val;

  SVN_ERR(svn_cache__membuffer_cache_create(&membuffer, 10*1024, 1, 0,
                                            TRUE, TRUE, pool));

  /* Create a cache with just one entry. */
  SVN_ERR(svn_cache__create_membuffer_cache(&cache,
                                            membuffer,
                                            serialize_revnum,
                                            raise_error_deserialize_func,
                                            APR_HASH_KEY_STRING,
                                            "cache:",
                                            SVN_CACHE__MEMBUFFER_DEFAULT_PRIORITY,
                                            FALSE,
                                            pool, pool));

  SVN_ERR(svn_cache__set(cache, "twenty", &twenty, pool));

  /* Test retrieving data from cache using full getter that
     always raises an error. */
  SVN_TEST_ASSERT_ERROR(
    svn_cache__get(&val, &found, cache, "twenty", pool),
    APR_EGENERAL);

  /* Test retrieving data from cache using partial getter that
     always raises an error. */
  SVN_TEST_ASSERT_ERROR(
    svn_cache__get_partial(&val, &found, cache, "twenty",
                           raise_error_partial_getter_func,
                           NULL, pool),
    APR_EGENERAL);

  /* Create a new cache. */
  SVN_ERR(svn_cache__membuffer_cache_create(&membuffer, 10*1024, 1, 0,
                                            TRUE, TRUE, pool));
  SVN_ERR(svn_cache__create_membuffer_cache(&cache,
                                            membuffer,
                                            serialize_revnum,
                                            deserialize_revnum,
                                            APR_HASH_KEY_STRING,
                                            "cache:",
                                            SVN_CACHE__MEMBUFFER_DEFAULT_PRIORITY,
                                            FALSE,
                                            pool, pool));

  /* Store one entry in cache. */
  SVN_ERR(svn_cache__set(cache, "twenty", &twenty, pool));

  /* Test setting data in cache using partial setter that
     always raises an error. */
  SVN_TEST_ASSERT_ERROR(
    svn_cache__set_partial(cache, "twenty",
                           raise_error_partial_setter_func,
                           NULL, pool),
    APR_EGENERAL);

  return SVN_NO_ERROR;
}