Package org.jboss.cache.interceptors

Examples of org.jboss.cache.interceptors.CacheStoreInterceptor

57
58
59
60
61
62
63
64
65
66
67
   }

   protected CacheStoreInterceptor findCacheStoreInterceptor(CacheSPI cache)
   {
      Iterator ints = cache.getInterceptorChain().iterator();
      CacheStoreInterceptor csi = null;
      while (ints.hasNext())
      {
         CommandInterceptor i = (CommandInterceptor) ints.next();
         if (i instanceof CacheStoreInterceptor)
         {
View Full Code Here
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
      // Note: because these tests are normally executed without a server, the interceptor
      // MBeans are usually not available for use in the tests.  Consequently it's necessary
      // to obtain references to the interceptors and work with them directly.
      CacheLoaderInterceptor loader = TestingUtil.findInterceptor(cache, CacheLoaderInterceptor.class);
      assertNotNull("CacheLoaderInterceptor not found.", loader);
      CacheStoreInterceptor store = TestingUtil.findInterceptor(cache, CacheStoreInterceptor.class);
      assertNotNull("CacheStoreInterceptor not found.", store);

      // verify cache loader statistics for entries loaded into cache
      int miss = 5;
      int load = 0;
      int stores = 5;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving a valid attribute and an invalid attribute
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + AUSTRIA, cache.get(AUSTRIA, AREA));

      // verify statistics after retrieving entries - misses should still be same since nodes were already loaded
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving an attribute for an invalid node
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + POLAND, cache.get(POLAND, CAPITAL));

      // verify statistics for after retrieving entries - misses should now be +1 after attempt to load Poland
      miss++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now evict Austria and confirm that it's no longer in cache
      cache.evict(AUSTRIA, false);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));

      // now try retrieving its attributes again - first retrieval should trigger a cache load
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after retrieving evicted entry - loads should now be +1
      load++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now remove Austria and confirm that it's not in cache or loader
      cache.removeNode(AUSTRIA);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));
      assertFalse("Retrieval error: did not expect to find node " + AUSTRIA + " in loader", cl.exists(AUSTRIA));

      // verify statistics after removing entry - should be unchanged
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving attributes again - each attempt should fail and cause a miss since node is now removed
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after trying to retrieve removed node's attributes - should be two more misses
      miss += 2;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add a new node - this should cause a store
      stores++;
      miss++;
      cache.put(POLAND, new HashMap<String, Object>());
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add two attributes - this should cause two stores
      stores += 2;
      cache.put(POLAND, CAPITAL, "Warsaw");
      cache.put(POLAND, CURRENCY, "Zloty");
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // evict Poland and then try to retrieve an invalid attribute - this will cause a load as the node is restored
      load++;
      cache.evict(POLAND, false);
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + POLAND, cache.get(POLAND, AREA));
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // reset statistics
      loader.resetStatistics();
      store.resetStatistics();

      // check the statistics again
      assertEquals("CacheLoaderLoads count error after reset: ", 0, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error after reset: ", 0, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error after reset: ", 0, store.getCacheLoaderStores());
   }
View Full Code Here
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
      // Note: because these tests are normally executed without a server, the interceptor
      // MBeans are usually not available for use in the tests.  Consequently it's necessary
      // to obtain references to the interceptors and work with them directly.
      CacheLoaderInterceptor loader = TestingUtil.findInterceptor(cache, CacheLoaderInterceptor.class);
      assertNotNull("CacheLoaderInterceptor not found.", loader);
      CacheStoreInterceptor store = TestingUtil.findInterceptor(cache, CacheStoreInterceptor.class);
      assertNotNull("CacheStoreInterceptor not found.", store);

      // verify cache loader statistics for entries loaded into cache
      int miss = 5;
      int load = 0;
      int stores = 5;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving a valid attribute and an invalid attribute
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + AUSTRIA, cache.get(AUSTRIA, AREA));

      // verify statistics after retrieving entries - misses should still be same since nodes were already loaded
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving an attribute for an invalid node
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + POLAND, cache.get(POLAND, CAPITAL));

      // verify statistics for after retrieving entries - misses should now be +1 after attempt to load Poland
      miss++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now evict Austria and confirm that it's no longer in cache
      cache.evict(AUSTRIA, false);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));

      // now try retrieving its attributes again - first retrieval should trigger a cache load
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after retrieving evicted entry - loads should now be +1
      load++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now remove Austria and confirm that it's not in cache or loader
      cache.removeNode(AUSTRIA);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));
      assertFalse("Retrieval error: did not expect to find node " + AUSTRIA + " in loader", cl.exists(AUSTRIA));

      // verify statistics after removing entry - should be unchanged
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving attributes again - each attempt should fail and cause a miss since node is now removed
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after trying to retrieve removed node's attributes - should be two more misses
      miss += 2;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add a new node - this should cause a store
      stores++;
      miss++;
      cache.put(POLAND, new HashMap<String, Object>());
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add two attributes - this should cause two stores
      stores += 2;
      cache.put(POLAND, CAPITAL, "Warsaw");
      cache.put(POLAND, CURRENCY, "Zloty");
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // evict Poland and then try to retrieve an invalid attribute - this will cause a load as the node is restored
      load++;
      cache.evict(POLAND, false);
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + POLAND, cache.get(POLAND, AREA));
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // reset statistics
      loader.resetStatistics();
      store.resetStatistics();

      // check the statistics again
      assertEquals("CacheLoaderLoads count error after reset: ", 0, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error after reset: ", 0, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error after reset: ", 0, store.getCacheLoaderStores());
   }
View Full Code Here
61
62
63
64
65
66
67
68
69
70
71
   }

   protected CacheStoreInterceptor findCacheStoreInterceptor(CacheSPI cache)
   {
      Iterator ints = cache.getInterceptorChain().iterator();
      CacheStoreInterceptor csi = null;
      while (ints.hasNext())
      {
         CommandInterceptor i = (CommandInterceptor) ints.next();
         if (i instanceof CacheStoreInterceptor)
         {
View Full Code Here
49
50
51
52
53
54
55
56
57
58
59
    }

    protected CacheStoreInterceptor findCacheStoreInterceptor(TreeCache cache)
    {
        Iterator ints = cache.getInterceptors().iterator();
        CacheStoreInterceptor csi = null;
        while (ints.hasNext())
        {
            Interceptor i = (Interceptor) ints.next();
            if (i instanceof CacheStoreInterceptor)
            {
View Full Code Here
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
      // Note: because these tests are normally executed without a server, the interceptor
      // MBeans are usually not available for use in the tests.  Consequently it's necessary
      // to obtain references to the interceptors and work with them directly.
      CacheLoaderInterceptor loader = getCacheLoaderInterceptor(cache);
      assertNotNull("CacheLoaderInterceptor not found.", loader);
      CacheStoreInterceptor store = getCacheStoreInterceptor(cache);
      assertNotNull("CacheStoreInterceptor not found.", store);
    
      // verify cache loader statistics for entries loaded into cache
      int miss = 0;
      int load = 0;
      int stores = 11;
      assertEquals("CacheLoaderLoads count error: ", new Long(0), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // now try retrieving a valid attribute and an invalid attribute
      Fqn key = Fqn.fromString("Europe/Austria");
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + key, cache.get(key, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + key, cache.get(key, AREA));
     
      // verify statistics after retrieving entries - misses should still be same since nodes were already loaded
      load++;
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // now try retrieving an attribute for an invalid node
      key = Fqn.fromString("Europe/Poland");
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + key, cache.get(key, CAPITAL));
     
      // verify statistics for after retrieving entries - misses should now be +1 after attempt to load Poland
      miss++;
      assertEquals("CacheLoaderLoads count error: ", new Long(1), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // now evict Austria and confirm that it's no longer in cache
      key = Fqn.fromString("Europe/Austria");
      cache.evict(key);
      assertFalse("Retrieval error: did not expect to find node " + key + " in cache", cache.exists(key));
     
      // now try retrieving its attributes again - first retrieval should trigger a cache load
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + key, cache.get(key, CAPITAL));
      assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + key, cache.get(key, CURRENCY));
     
      // verify statistics after retrieving evicted entry - loads should now be +1
      load++;
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // now remove Austria and confirm that it's not in cache or loader
      cache.remove(key);
      assertFalse("Retrieval error: did not expect to find node " + key + " in cache", cache.exists(key));
      assertFalse("Retrieval error: did not expect to find node " + key + " in loader", cl.exists(key));
     
      // verify statistics after removing entry - should be unchanged
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // now try retrieving attributes again - each attempt should fail and cause a miss since node is now removed
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + key, cache.get(key, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + CURRENCY + " for " + key, cache.get(key, CURRENCY));
     
      // verify statistics after trying to retrieve removed node's attributes - should be two more misses
      miss += 2;
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // add a new node - this should cause a store
      stores++;
      cache.put("Europe/Poland", new HashMap());
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // add two attributes - this should cause two stores
      stores+=2;
      cache.put("Europe/Poland", CAPITAL, "Warsaw");
      cache.put("Europe/Poland", CURRENCY, "Zloty");
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // evict Poland and then try to retrieve an invalid attribute - this will cause a load as the node is restored
      load++;
      key = Fqn.fromString("Europe/Poland");
      cache.evict(key);
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + key, cache.get(key, AREA));
      assertEquals("CacheLoaderLoads count error: ", new Long(load), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error: ", new Long(miss), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error: ", new Long(stores), new Long(store.getCacheLoaderStores()));
     
      // reset statistics
      loader.resetStatistics();
      store.resetStatistics();
    
      // check the statistics again
      assertEquals("CacheLoaderLoads count error after reset: ", new Long(0), new Long(loader.getCacheLoaderLoads()));
      assertEquals("CacheLoaderMisses count error after reset: ", new Long(0), new Long(loader.getCacheLoaderMisses()));
      assertEquals("CacheLoaderStores count error after reset: ", new Long(0), new Long(store.getCacheLoaderStores()));
   }
View Full Code Here
51
52
53
54
55
56
57
58
59
60
61
   }

   protected CacheStoreInterceptor findCacheStoreInterceptor(CacheSPI cache)
   {
      Iterator ints = cache.getInterceptorChain().iterator();
      CacheStoreInterceptor csi = null;
      while (ints.hasNext())
      {
         Interceptor i = (Interceptor) ints.next();
         if (i instanceof CacheStoreInterceptor)
         {
View Full Code Here
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
      // Note: because these tests are normally executed without a server, the interceptor
      // MBeans are usually not available for use in the tests.  Consequently it's necessary
      // to obtain references to the interceptors and work with them directly.
      CacheLoaderInterceptor loader = TestingUtil.findInterceptor(cache, CacheLoaderInterceptor.class);
      assertNotNull("CacheLoaderInterceptor not found.", loader);
      CacheStoreInterceptor store = TestingUtil.findInterceptor(cache, CacheStoreInterceptor.class);
      assertNotNull("CacheStoreInterceptor not found.", store);

      // verify cache loader statistics for entries loaded into cache
      int miss = 0;
      int load = 0;
      int stores = 5;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving a valid attribute and an invalid attribute
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + AUSTRIA, cache.get(AUSTRIA, AREA));
      load++; // since we did a get on a non-existent key which triggered a load

      // verify statistics after retrieving entries - misses should still be same since nodes were already loaded
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving an attribute for an invalid node
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + POLAND, cache.get(POLAND, CAPITAL));

      // verify statistics for after retrieving entries - misses should now be +1 after attempt to load Poland
      miss++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now evict Austria and confirm that it's no longer in cache
      cache.evict(AUSTRIA, false);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));

      // now try retrieving its attributes again - first retrieval should trigger a cache load
      assertNotNull("Retrieval error: expected to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after retrieving evicted entry - loads should now be +1
      load++;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now remove Austria and confirm that it's not in cache or loader
      cache.removeNode(AUSTRIA);
      assertNull("Retrieval error: did not expect to find node " + AUSTRIA + " in cache", cache.peek(AUSTRIA, false));
      assertFalse("Retrieval error: did not expect to find node " + AUSTRIA + " in loader", cl.exists(AUSTRIA));

      // verify statistics after removing entry - should be unchanged
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // now try retrieving attributes again - each attempt should fail and cause a miss since node is now removed
      assertNull("Retrieval error: did not expect to retrieve " + CAPITAL + " for " + AUSTRIA, cache.get(AUSTRIA, CAPITAL));
      assertNull("Retrieval error: did not expect to retrieve " + CURRENCY + " for " + AUSTRIA, cache.get(AUSTRIA, CURRENCY));

      // verify statistics after trying to retrieve removed node's attributes - should be two more misses
      miss += 2;
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add a new node - this should cause a store
      stores++;
      cache.put(POLAND, new HashMap<String, Object>());
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // add two attributes - this should cause two stores
      // plus one load as we're doing put(k, v)
      stores += 2;
      load++;
      cache.put(POLAND, CAPITAL, "Warsaw");
      cache.put(POLAND, CURRENCY, "Zloty");
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // evict Poland and then try to retrieve an invalid attribute - this will cause a load as the node is restored
      load++;
      cache.evict(POLAND, false);
      assertNull("Retrieval error: did not expect to retrieve " + AREA + " for " + POLAND, cache.get(POLAND, AREA));
      assertEquals("CacheLoaderLoads count error: ", load, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error: ", miss, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error: ", stores, store.getCacheLoaderStores());

      // reset statistics
      loader.resetStatistics();
      store.resetStatistics();

      // check the statistics again
      assertEquals("CacheLoaderLoads count error after reset: ", 0, loader.getCacheLoaderLoads());
      assertEquals("CacheLoaderMisses count error after reset: ", 0, loader.getCacheLoaderMisses());
      assertEquals("CacheLoaderStores count error after reset: ", 0, store.getCacheLoaderStores());
   }
View Full Code Here
TOP

Related Classes of org.jboss.cache.interceptors.CacheStoreInterceptor

  • org.jboss.cache.Fqn
  • org.jboss.cache.GlobalTransaction
  • org.jboss.cache.loader.SharedCacheLoaderTest
  • org.jboss.cache.marshall.JBCMethodCall
  • org.jboss.cache.mgmt.CacheLoaderTest
  • org.jboss.cache.Modification
  • org.jboss.cache.NodeSPI
  • org.jboss.cache.transaction.GlobalTransaction
  • org.jboss.cache.transaction.TransactionEntry
  • org.jboss.cache.TransactionEntry
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.