← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ehcache/trusty

« back to all changes in this revision

Viewing changes to src/test/java/net/sf/ehcache/pool/sizeof/FilteredSizeOfTest.java

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg
  • Date: 2013-05-06 14:53:07 UTC
  • mfrom: (1.1.7) (2.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20130506145307-v5bhw5yu70re00l3
Tags: 2.6.7-1
* Team upload.
* New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/java/net/sf/ehcache/pool/sizeof/FilteredSizeOfTest.java
1
1
package net.sf.ehcache.pool.sizeof;
2
2
 
3
 
import static org.hamcrest.CoreMatchers.is;
4
 
import static org.junit.Assert.assertThat;
 
3
import java.io.File;
 
4
import java.io.FileOutputStream;
 
5
import java.io.InputStream;
 
6
import java.net.URLClassLoader;
5
7
 
 
8
import net.sf.ehcache.pool.SizeOfEngine;
 
9
import net.sf.ehcache.pool.impl.DefaultSizeOfEngine;
 
10
import net.sf.ehcache.pool.sizeof.annotationfiltered.AnnotationFilteredPackage;
 
11
import net.sf.ehcache.pool.sizeof.annotationfiltered.custom.CustomAnnotationFilteredPackage;
6
12
import net.sf.ehcache.pool.sizeof.filter.AnnotationSizeOfFilter;
7
13
import net.sf.ehcache.pool.sizeof.annotations.IgnoreSizeOf;
8
14
import net.sf.ehcache.pool.sizeof.filter.ResourceSizeOfFilter;
 
15
import net.sf.ehcache.pool.sizeof.resourcefiltered.ResourceFilteredPackage;
9
16
 
 
17
import org.junit.Assume;
10
18
import org.junit.BeforeClass;
11
19
import org.junit.Test;
12
20
 
 
21
import static org.hamcrest.CoreMatchers.allOf;
 
22
import static org.hamcrest.core.IsEqual.equalTo;
 
23
import static org.hamcrest.core.IsInstanceOf.instanceOf;
 
24
import static org.hamcrest.number.OrderingComparison.greaterThan;
 
25
import static org.hamcrest.number.OrderingComparison.lessThan;
 
26
import static org.junit.Assert.assertThat;
 
27
 
13
28
public class FilteredSizeOfTest extends AbstractSizeOfTest {
14
29
 
15
 
  private static long deepSizeOf(SizeOf sizeOf, Object... obj) {
16
 
    return sizeOf.deepSizeOf(1000, true, obj).getCalculated();
17
 
  }
18
 
 
19
 
  @BeforeClass
20
 
  public static void setup() {
21
 
    deepSizeOf(new CrossCheckingSizeOf(), new Object());
22
 
    System.out.println("Testing for a " + System.getProperty("java.version") + " JDK " +
23
 
                       ") on a " + System.getProperty("sun.arch.data.model") + "-bit VM " +
24
 
                       "(compressed-oops: " + COMPRESSED_OOPS +
25
 
                       ", Hotspot CMS: " + HOTSPOT_CMS +
26
 
                       ")");
27
 
  }
28
 
 
29
 
  @Test
30
 
  public void testAnnotationFiltering() throws Exception {
31
 
    SizeOf sizeOf = new CrossCheckingSizeOf(new AnnotationSizeOfFilter());
32
 
    if (System.getProperty("java.version").startsWith("1.5")) {
33
 
      if (IS_64_BIT) {
34
 
        System.out.println("asserting 1.5 / 64-bit values");
35
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(192L));
36
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(200L));
37
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(224L));
38
 
      } else {
39
 
        System.out.println("asserting 1.5 / 32-bit values");
40
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(168L));
41
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(168L));
42
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(184L));
43
 
      }
44
 
    } else {
45
 
      if (IS_64_BIT) {
46
 
        if (COMPRESSED_OOPS) {
47
 
          if (HOTSPOT_CMS) {
48
 
            System.out.println("asserting 1.6+ / 64-bit / compressed OOPs / Hotspot CMS values");
49
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(168L));
50
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(176L));
51
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(200L));
52
 
          } else {
53
 
            System.out.println("asserting 1.6+ / 64-bit / compressed OOPs / non-Hotspot CMS values");
54
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(168L));
55
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(176L));
56
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(192L));
57
 
          }
58
 
        } else if (IS_JROCKIT) {
59
 
            System.out.println("asserting JRockit 1.6+ / 64-bit / 4GB compressed refs values");
60
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(184L));
61
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(184L));
62
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(208L));
63
 
        } else if (IS_IBM) {
64
 
            System.out.println("asserting IBM 1.6+ / 64-bit / (con-compressed) values");
65
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(200L));
66
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(208L));
67
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(240L));
68
 
        } else {
69
 
          if (HOTSPOT_CMS) {
70
 
            System.out.println("asserting 1.6+ / 64-bit / plain OOPs / Hotspot CMS values");
71
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(192L));
72
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(200L));
73
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(224L));
74
 
          } else {
75
 
            System.out.println("asserting 1.6+ / 64-bit / plain OOPs / non-Hotspot CMS values");
76
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(192L));
77
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(200L));
78
 
            assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(224L));
79
 
          }
80
 
        }
81
 
      } else if (IS_IBM) {
82
 
          System.out.println("asserting IBM 1.6+ / 32-bit values");
83
 
          assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(168L));
84
 
          assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(176L));
85
 
          assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(192L));
86
 
      } else if (IS_JROCKIT) {
87
 
        System.out.println("asserting JRockit 1.6+ / 32-bit values");
88
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(184L));
89
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(184L));
90
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(208L));
91
 
      } else {
92
 
        System.out.println("asserting 1.6+ / 32-bit values");
93
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), is(168L));
94
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredSubclass()), is(168L));
95
 
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredReferrer()), is(184L));
96
 
      }
97
 
    }
98
 
  }
99
 
 
100
 
  @Test
101
 
  public void testResourceFiltering() throws Exception {
102
 
    SizeOf sizeOf = new CrossCheckingSizeOf(new ResourceSizeOfFilter(FilteredSizeOfTest.class.getClassLoader().getResource("sizeof.filter.fields")));
103
 
    if (System.getProperty("java.version").startsWith("1.5")) {
104
 
      if (IS_64_BIT) {
105
 
        System.out.println("asserting 1.5 / 64-bit values");
106
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(192L));
107
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(200L));
108
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(224L));
109
 
      } else {
110
 
        System.out.println("asserting 1.5 / 32-bit values");
111
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(168L));
112
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(168L));
113
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(184L));
114
 
      }
115
 
    } else {
116
 
      if (IS_64_BIT) {
117
 
        if (COMPRESSED_OOPS) {
118
 
          if (HOTSPOT_CMS) {
119
 
            System.out.println("asserting 1.6+ / 64-bit / compressed OOPs / Hotspot CMS values");
120
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(168L));
121
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(176L));
122
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(200L));
123
 
          } else {
124
 
            System.out.println("asserting 1.6+ / 64-bit / compressed OOPs / non-Hotspot CMS values");
125
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(168L));
126
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(176L));
127
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(192L));
128
 
          }
129
 
        } else if (IS_JROCKIT) {
130
 
            System.out.println("asserting JRockit 1.6+ / 64-bit / 4GB compressed refs values");
131
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(184L));
132
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(184L));
133
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(208L));
134
 
        } else if (IS_IBM) {
135
 
            System.out.println("asserting IBM 1.6+ / 64-bit / (non-compressed) refs values");
136
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(200L));
137
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(208L));
138
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(240L));
139
 
        } else {
140
 
          if (HOTSPOT_CMS) {
141
 
            System.out.println("asserting 1.6+ / 64-bit / plain OOPs / Hotspot CMS values");
142
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(192L));
143
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(200L));
144
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(224L));
145
 
          } else {
146
 
            System.out.println("asserting 1.6+ / 64-bit / plain OOPs / non-Hotspot CMS values");
147
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(192L));
148
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(200L));
149
 
            assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(224L));
150
 
          }
151
 
        }
152
 
      } else if (IS_IBM) {
153
 
          System.out.println("asserting IBM 1.6+ / 32-bit values");
154
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(168L));
155
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(176L));
156
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(192L));
157
 
      } else if (IS_JROCKIT) {
158
 
        System.out.println("asserting JRockit 1.6+ / 32-bit values");
159
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(184L));
160
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(184L));
161
 
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(208L));
162
 
      } else {
163
 
          System.out.println("asserting 1.6+ / 32-bit values");
164
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), is(168L));
165
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredSubclass()), is(168L));
166
 
          assertThat(deepSizeOf(sizeOf, new ResourceFilteredReferrer()), is(184L));
167
 
        }
168
 
    }
169
 
  }
170
 
 
171
 
  public static class AnnotationFilteredClass {
172
 
    @IgnoreSizeOf
173
 
    private final byte[] bigArray = new byte[16 * 1024];
174
 
 
175
 
    @IgnoreSizeOf
176
 
    private final byte[] mediumArray = new byte[1024];
177
 
 
178
 
    private final byte[] smallArray = new byte[128];
179
 
  }
180
 
 
181
 
  public static class AnnotationFilteredSubclass extends AnnotationFilteredClass {
182
 
    private final int field = 0;
183
 
  }
184
 
 
185
 
  public static class AnnotationFilteredReferrer {
186
 
    private final AnnotationFilteredSubclass reference = new AnnotationFilteredSubclass();
187
 
  }
188
 
 
189
 
  public static class ResourceFilteredClass {
190
 
    private final byte[] bigArray = new byte[16 * 1024];
191
 
 
192
 
    private final byte[] mediumArray = new byte[1024];
193
 
 
194
 
    private final byte[] smallArray = new byte[128];
195
 
  }
196
 
 
197
 
  public static class ResourceFilteredSubclass extends ResourceFilteredClass {
198
 
    private final int field = 0;
199
 
  }
200
 
 
201
 
  public static class ResourceFilteredReferrer {
202
 
    private final ResourceFilteredSubclass reference = new ResourceFilteredSubclass();
203
 
  }
 
30
    private static long deepSizeOf(SizeOf sizeOf, Object... obj) {
 
31
        return sizeOf.deepSizeOf(1000, true, obj).getCalculated();
 
32
    }
 
33
 
 
34
    @BeforeClass
 
35
    public static void setup() {
 
36
        deepSizeOf(new CrossCheckingSizeOf(), new Object());
 
37
        System.out.println("Testing for a " + System.getProperty("java.version") + " JDK "
 
38
                + ") on a " + System.getProperty("sun.arch.data.model") + "-bit VM "
 
39
                + "(compressed-oops: " + COMPRESSED_OOPS
 
40
                + ", Hotspot CMS: " + HOTSPOT_CMS
 
41
                + ")");
 
42
    }
 
43
 
 
44
    @Test
 
45
    public void testAnnotationFiltering() throws Exception {
 
46
        SizeOf sizeOf = new CrossCheckingSizeOf(new AnnotationSizeOfFilter());
 
47
    
 
48
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredField()), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
49
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredClass()), equalTo(0L));
 
50
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredPackage()), equalTo(0L));
 
51
    
 
52
        assertThat(deepSizeOf(sizeOf, new AnnotationFilteredFieldSubclass()), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
53
    
 
54
        long emptyReferrerSize = deepSizeOf(sizeOf, new Referrer(null));
 
55
        assertThat(deepSizeOf(sizeOf, new Referrer(new AnnotationFilteredClass())), equalTo(emptyReferrerSize));
 
56
        assertThat(deepSizeOf(sizeOf, new Referrer(new AnnotationFilteredPackage())), equalTo(emptyReferrerSize));
 
57
        assertThat(deepSizeOf(sizeOf, new Parent()), equalTo(0L));
 
58
        assertThat(deepSizeOf(sizeOf, new Child()), equalTo(0L));
 
59
        assertThat(deepSizeOf(sizeOf, new ChildChild()), equalTo(0L));
 
60
        assertThat(deepSizeOf(sizeOf, new ChildChildChild()), equalTo(0L));
 
61
    }
 
62
 
 
63
    @Test
 
64
    public void testCustomAnnotationFiltering() throws Exception {
 
65
        SizeOf sizeOf = new CrossCheckingSizeOf(new AnnotationSizeOfFilter());
 
66
        assertThat(deepSizeOf(sizeOf, new MatchingPatternOrNotAnnotationFilteredField()), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
67
        assertThat(deepSizeOf(sizeOf, new MatchingPatternAnnotation()), equalTo(0L));
 
68
        assertThat(deepSizeOf(sizeOf, new MatchingPatternAnnotationChild()), equalTo(0L));
 
69
        assertThat(deepSizeOf(sizeOf, new MatchingPatternAnnotationNoInheritedChild()), allOf(greaterThan(4L)));
 
70
        assertThat(deepSizeOf(sizeOf, new NonMatchingPatternAnnotation1()), allOf(greaterThan(4L)));
 
71
        assertThat(deepSizeOf(sizeOf, new NonMatchingPatternAnnotation2()), allOf(greaterThan(4L)));
 
72
        assertThat(deepSizeOf(sizeOf, new CustomAnnotationFilteredPackage()), equalTo(0L));
 
73
    }
 
74
        
 
75
    @Test(expected=IllegalStateException.class)
 
76
    public void testNotPossibleToHaveTwoIgnoreSizeOfAnnotations() throws Exception {
 
77
        SizeOf sizeOf = new CrossCheckingSizeOf(new AnnotationSizeOfFilter());
 
78
        deepSizeOf(sizeOf, new AnnotatedTwice());
 
79
    }
 
80
 
 
81
    @Test
 
82
    public void testResourceFiltering() throws Exception {
 
83
        SizeOf sizeOf = new CrossCheckingSizeOf(new ResourceSizeOfFilter(FilteredSizeOfTest.class.getClassLoader().getResource("sizeof.filter.fields")));
 
84
 
 
85
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredField()), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
86
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredClass()), equalTo(0L));
 
87
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredPackage()), equalTo(0L));
 
88
    
 
89
        assertThat(deepSizeOf(sizeOf, new ResourceFilteredFieldSubclass()), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
90
    
 
91
        long emptyReferrerSize = deepSizeOf(sizeOf, new Referrer(null));
 
92
        assertThat(deepSizeOf(sizeOf, new Referrer(new ResourceFilteredClass())), equalTo(emptyReferrerSize));
 
93
        assertThat(deepSizeOf(sizeOf, new Referrer(new ResourceFilteredPackage())), equalTo(emptyReferrerSize));
 
94
    }
 
95
 
 
96
    private static SizeOfEngine getLoaderIsolatedEngine(int depth, boolean abort) {
 
97
        ClassLoader current = FilteredSizeOfTest.class.getClassLoader();
 
98
        Assume.assumeThat(current, instanceOf(URLClassLoader.class));
 
99
        ClassLoader mirror = new URLClassLoader(((URLClassLoader) current).getURLs(), current) {
 
100
 
 
101
            @Override
 
102
            protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
 
103
                if ("net.sf.ehcache.pool.impl.DefaultSizeOfEngine".equals(name)) {
 
104
                    Class klazz = findLoadedClass(name);
 
105
                    if (klazz == null) {
 
106
                        klazz = findClass(name);
 
107
                        if (resolve) {
 
108
                            resolveClass(klazz);
 
109
                        }
 
110
                    }
 
111
                    return klazz;
 
112
                } else {
 
113
                    return super.loadClass(name, resolve);
 
114
                }
 
115
            }
 
116
        };
 
117
 
 
118
        try {
 
119
            return (SizeOfEngine) mirror.loadClass("net.sf.ehcache.pool.impl.DefaultSizeOfEngine").getConstructor(Integer.TYPE, Boolean.TYPE).newInstance(1000, false);
 
120
        } catch (Exception ex) {
 
121
            throw new AssertionError(ex);
 
122
        }
 
123
    }
 
124
  
 
125
    private static void testSizeOfEngineFiltering(String filter) {
 
126
        System.setProperty(DefaultSizeOfEngine.USER_FILTER_RESOURCE, filter);
 
127
        try {
 
128
            SizeOfEngine engine = getLoaderIsolatedEngine(1000, false);
 
129
 
 
130
            assertThat(engine.sizeOf(new ResourceFilteredField(), null, null).getCalculated(), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
131
            assertThat(engine.sizeOf(new ResourceFilteredClass(), null, null).getCalculated(), equalTo(0L));
 
132
            assertThat(engine.sizeOf(new ResourceFilteredPackage(), null, null).getCalculated(), equalTo(0L));
 
133
 
 
134
            assertThat(engine.sizeOf(new ResourceFilteredFieldSubclass(), null, null).getCalculated(), allOf(greaterThan(128L), lessThan(16 * 1024L)));
 
135
    
 
136
            long emptyReferrerSize = engine.sizeOf(new Referrer(null), null, null).getCalculated();
 
137
            assertThat(engine.sizeOf(new Referrer(new ResourceFilteredClass()), null, null).getCalculated(), equalTo(emptyReferrerSize));
 
138
            assertThat(engine.sizeOf(new Referrer(new ResourceFilteredPackage()), null, null).getCalculated(), equalTo(emptyReferrerSize));
 
139
        } finally {
 
140
            System.clearProperty(DefaultSizeOfEngine.USER_FILTER_RESOURCE);
 
141
        }
 
142
    }
 
143
    
 
144
    @Test
 
145
    public void testResourceFilterLoading() throws Exception {
 
146
        testSizeOfEngineFiltering("sizeof.filter.fields");
 
147
    }
 
148
  
 
149
    @Test
 
150
    public void testFileFilterLoading() throws Exception {
 
151
        File tempFilterFile = File.createTempFile("FilteredSizeOfTest", ".filter");
 
152
        try {
 
153
            tempFilterFile.deleteOnExit();
 
154
            FileOutputStream fout = new FileOutputStream(tempFilterFile);
 
155
            try {
 
156
                InputStream in = FilteredSizeOfTest.class.getResourceAsStream("/sizeof.filter.fields");
 
157
                try {
 
158
                    while (true) {
 
159
                        int read = in.read();
 
160
                        if (read < 0) {
 
161
                            break;
 
162
                        } else {
 
163
                            fout.write(read);
 
164
                        }
 
165
                    }
 
166
                } finally {
 
167
                    in.close();
 
168
                }
 
169
            } finally {
 
170
                fout.close();
 
171
            }
 
172
            testSizeOfEngineFiltering(tempFilterFile.getAbsolutePath());
 
173
        } finally {
 
174
            assertThat(tempFilterFile.delete(), equalTo(true));
 
175
        }
 
176
    }
 
177
 
 
178
    @Test
 
179
    public void testUrlFilterLoading() throws Exception {
 
180
        testSizeOfEngineFiltering(FilteredSizeOfTest.class.getResource("/sizeof.filter.fields").toExternalForm());
 
181
    }
 
182
 
 
183
    public static class AnnotationFilteredField {
 
184
  
 
185
        @IgnoreSizeOf
 
186
        private final byte[] bigArray = new byte[16 * 1024];
 
187
        private final byte[] smallArray = new byte[128];
 
188
    }
 
189
  
 
190
    public static class AnnotationFilteredFieldSubclass extends AnnotationFilteredField {
 
191
    }
 
192
    
 
193
    @IgnoreSizeOf
 
194
    public static class AnnotationFilteredClass {
 
195
    
 
196
        private final byte[] bigArray = new byte[16 * 1024];
 
197
    }
 
198
 
 
199
    @IgnoreSizeOf(inherited = true)
 
200
    public static class Parent {
 
201
    }
 
202
 
 
203
    public static class Child extends Parent {
 
204
    }
 
205
 
 
206
    @IgnoreSizeOf
 
207
    public static class ChildChild extends Child {
 
208
    }
 
209
 
 
210
    public static class ChildChildChild extends ChildChild {
 
211
    }
 
212
 
 
213
    @com.terracotta.ehcache.special.annotation.IgnoreSizeOf(inherited=true)
 
214
    public static class MatchingPatternAnnotation {
 
215
    }
 
216
 
 
217
    public static class MatchingPatternAnnotationChild extends MatchingPatternAnnotation{
 
218
    }
 
219
 
 
220
    @com.terracotta.ehcache.special.annotation.no.inherited.IgnoreSizeOf
 
221
    public static class MatchingPatternAnnotationNoInherited {
 
222
    }
 
223
 
 
224
    public static class MatchingPatternAnnotationNoInheritedChild extends MatchingPatternAnnotationNoInherited{
 
225
    }
 
226
 
 
227
    @com.terracotta.ehcache.special.annotation.IgnoreSizeOffff
 
228
    public static class NonMatchingPatternAnnotation1 {
 
229
    }
 
230
 
 
231
    @com.terracotta.special.annotation.IgnoreSizeOf
 
232
    public static class NonMatchingPatternAnnotation2 {
 
233
    }
 
234
 
 
235
    @com.terracotta.ehcache.special.annotation.IgnoreSizeOf
 
236
    @IgnoreSizeOf
 
237
    public static class AnnotatedTwice {
 
238
    }
 
239
 
 
240
    public static class MatchingPatternOrNotAnnotationFilteredField {
 
241
        @com.terracotta.ehcache.special.annotation.IgnoreSizeOf
 
242
        private final byte[] matchingBigArray = new byte[16 * 1024];
 
243
        @com.terracotta.special.annotation.IgnoreSizeOf
 
244
        private final byte[] nonMatchingSmallArray = new byte[128];
 
245
    }
 
246
 
 
247
    public static class ResourceFilteredField {
 
248
 
 
249
        private final byte[] bigArray = new byte[16 * 1024];
 
250
        private final byte[] smallArray = new byte[128];
 
251
    }
 
252
 
 
253
    public static class ResourceFilteredFieldSubclass extends ResourceFilteredField {
 
254
    }
 
255
 
 
256
    public static class ResourceFilteredClass {
 
257
 
 
258
        private final byte[] bigArray = new byte[6 * 1024];
 
259
    }
 
260
 
 
261
    public static class Referrer {
 
262
 
 
263
        private final Object reference;
 
264
 
 
265
        public Referrer(Object obj) {
 
266
            this.reference = obj;
 
267
        }
 
268
    }
204
269
}