1 /***
2 * Copyright 2003-2010 Terracotta, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package net.sf.ehcache;
18
19
20 import static junit.framework.Assert.fail;
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertTrue;
24
25 import java.io.ByteArrayInputStream;
26 import java.io.ByteArrayOutputStream;
27 import java.io.IOException;
28 import java.io.NotSerializableException;
29 import java.io.ObjectInputStream;
30 import java.io.ObjectOutputStream;
31 import java.io.Serializable;
32
33 import org.junit.Test;
34 import org.slf4j.Logger;
35 import org.slf4j.LoggerFactory;
36
37 /***
38 * Test cases for the Element.
39 *
40 * @author <a href="mailto:gluck@thoughtworks.com">Greg Luck</a>
41 * @version $Id: ElementTest.html 13146 2011-08-01 17:12:39Z oletizi $
42 */
43 public class ElementTest extends AbstractCacheTest {
44
45 private static final Logger LOG = LoggerFactory.getLogger(ElementTest.class.getName());
46
47
48 /***
49 * ehcache-1.2 adds support to Objects in addition to Serializable. Check that this works
50 */
51 @Test
52 public void testObjectAccess() {
53 Object key = new Object();
54 Object value = new Object();
55 Element element = new Element(key, value);
56
57 assertEquals(key, element.getObjectKey());
58 assertEquals(value, element.getObjectValue());
59
60
61 try {
62 element.getKey();
63 } catch (CacheException e) {
64
65 }
66 assertEquals(value, element.getObjectValue());
67
68 }
69
70 /***
71 * ehcache-1.1 and earlier exclusively uses Serializable keys and values. Check that this works
72 */
73 @Test
74 public void testSerializableAccess() {
75 Serializable key = "";
76 Serializable value = "";
77 Element element = new Element(key, value);
78
79
80 assertEquals(key, element.getObjectKey());
81 assertEquals(value, element.getObjectValue());
82
83
84 assertEquals(key, element.getObjectKey());
85 assertEquals(value, element.getObjectValue());
86
87
88 }
89
90 /***
91 * Tests that isSerializable does not blow up is if either key or value is null
92 */
93 @Test
94 public void testIsSerializable() {
95
96 Element element = new Element(null, null);
97 assertTrue(element.isSerializable());
98
99
100 Element elementWithNullValue = new Element("1", null);
101 assertTrue(elementWithNullValue.isSerializable());
102
103
104 Element elementWithNullKey = new Element(null, "1");
105 assertTrue(elementWithNullValue.isSerializable());
106
107 Element elementWithObjectKey = new Element(new Object(), "1");
108 assertTrue(elementWithNullValue.isSerializable());
109
110
111 }
112
113 /***
114 * Tests the robustness of equals
115 */
116 @Test
117 public void testEquals() {
118
119 Element element = new Element("key", "value");
120 assertFalse(element.equals("dog"));
121 assertTrue(element.equals(element));
122 assertFalse(element.equals(null));
123 assertFalse(element.equals(new Element("cat", "hat")));
124 }
125
126 /***
127 * Tests that the full constructor sets everything right.
128 */
129 @Test
130 public void testFullConstructor() {
131
132 Element element = new Element("key", "value", 1L, 123L, 1234L, 12345L, 123456L);
133 assertEquals("key", element.getKey());
134 assertEquals("value", element.getValue());
135 assertEquals(1L, element.getVersion());
136 assertEquals(123L, element.getCreationTime());
137 assertEquals(1234L, element.getLastAccessTime());
138 assertEquals(12345L, element.getLastUpdateTime());
139 assertEquals(123456L, element.getHitCount());
140
141 }
142
143
144 /***
145 * Shows that null, regardless of class can be serialized.
146 *
147 * @throws IOException
148 * @throws ClassNotFoundException
149 */
150 @Test
151 public void testSerializable() throws IOException, ClassNotFoundException {
152
153 String string1 = "string";
154 String string2 = null;
155 Object object1 = new Object();
156 Object object2 = null;
157
158 ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
159 ObjectOutputStream objectOutputStream = new ObjectOutputStream(baos);
160 objectOutputStream.writeObject(string1);
161 objectOutputStream.writeObject(string2);
162
163 try {
164 objectOutputStream.writeObject(object1);
165 fail();
166 } catch (NotSerializableException e) {
167
168 }
169 try {
170 objectOutputStream.writeObject(object2);
171 } catch (NotSerializableException e) {
172
173 }
174
175
176 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
177 ObjectInputStream objectInputStream = new ObjectInputStream(bais);
178 assertEquals("string", objectInputStream.readObject());
179 assertEquals(null, objectInputStream.readObject());
180 }
181
182
183 }