Package org.springsource.loaded.test.infra

Examples of org.springsource.loaded.test.infra.TestClassloaderWithRewriting

40
41
42
43
44
45
46
47
48
49
50
  // Accessing a field from another type, which just turns into property
  // access via a method
  @Test
  public void fields() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String a = "simple.Front";
    String b = "simple.Back";
    TypeRegistry r = getTypeRegistry(a + "," + b);
    ReloadableType rtypea = r.addType(a, loadBytesForClass(a));
    ReloadableType rtypeb = r.addType(b, loadBytesForClass(b));
View Full Code Here
66
67
68
69
70
71
72
73
74
75
76
  // test is too sensitive to changes between groovy compiler versions
  @Ignore
  @Test
  public void reflection() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String a = "simple.SelfReflector";
    TypeRegistry r = getTypeRegistry(a);
    ReloadableType rtypea = r.addType(a, loadBytesForClass(a));
    result = runUnguarded(rtypea.getClazz(), "run");
View Full Code Here
81
82
83
84
85
86
87
88
89
90
91
  // TODO why doesn't this need swapInit? Is that only required for static
  // field constants?
  @Test
  public void localVariables() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String a = "simple.LFront";
    TypeRegistry r = getTypeRegistry(a);
    ReloadableType rtypea = r.addType(a, loadBytesForClass(a));
    result = runUnguarded(rtypea.getClazz(), "run");
    assertEquals("abc", result.returnValue);
View Full Code Here
100
101
102
103
104
105
106
107
108
109
110
    assertEquals(88, result.returnValue);
  }

  @Test
  public void fieldsOnInstance() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String a = "simple.Front";
    String b = "simple.Back";
    TypeRegistry r = getTypeRegistry(a + "," + b);
    ReloadableType rtypea = r.addType(a, loadBytesForClass(a));
    ReloadableType rtypeb = r.addType(b, loadBytesForClass(b));
View Full Code Here
126
127
128
129
130
131
132
133
134
135
136
  }

  // Changing the return value within a method
  @Test
  public void basic() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.Basic";
    TypeRegistry r = getTypeRegistry(t);
    ReloadableType rtype = r.addType(t, loadBytesForClass(t));
    result = runUnguarded(rtype.getClazz(), "run");
    assertEquals("hello", result.returnValue);
View Full Code Here
139
140
141
142
143
144
145
146
147
148
149
    assertEquals("goodbye", result.returnValue);
  }

  @Test
  public void basicInstance() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.Basic";
    TypeRegistry r = getTypeRegistry(t);
    ReloadableType rtype = r.addType(t, loadBytesForClass(t));
    Object instance = null;
    instance = rtype.getClazz().newInstance();
View Full Code Here
219
220
221
222
223
224
225
226
227
228
229
  // The method calls another method to get the return string, test
  // that when the method we are calling changes, we do call the new
  // one (simply checking the callsite cache is reset)
  @Test
  public void basic2() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.BasicB";
    TypeRegistry r = getTypeRegistry(t);
    ReloadableType rtype = r.addType(t, loadBytesForClass(t));
    result = runUnguarded(rtype.getClazz(), "run");
    assertEquals("hello", result.returnValue);
View Full Code Here
233
234
235
236
237
238
239
240
241
242
243
  }

  // Similar to BasicB but now using non-static methods
  @Test
  public void basic3() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.BasicC";
    TypeRegistry r = getTypeRegistry(t);
    ReloadableType rtype = r.addType(t, loadBytesForClass(t));
    result = runUnguarded(rtype.getClazz(), "run");
    assertEquals("hello", result.returnValue);
View Full Code Here
249
250
251
252
253
254
255
256
257
258
259
  // Now calling between two different types to check if we have
  // to clear more than 'our' state on a reload. In this scenario
  // the method being called is static
  @Test
  public void basic4() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.BasicD";
    String target = "simple.BasicDTarget";
    TypeRegistry r = getTypeRegistry(t + "," + target);
    ReloadableType rtype = r.addType(t, loadBytesForClass(t));
    ReloadableType rtypeTarget = r.addType(target, loadBytesForClass(target));
View Full Code Here
266
267
268
269
270
271
272
273
274
275
276
  }

  // Calling from one type to another, now the methods are non-static
  @Test
  public void basic5() throws Exception {
    binLoader = new TestClassloaderWithRewriting();
    String t = "simple.BasicE";
    String target = "simple.BasicETarget";

    TypeRegistry r = getTypeRegistry(t + "," + target);
View Full Code Here
TOP

Related Classes of org.springsource.loaded.test.infra.TestClassloaderWithRewriting

  • org.springsource.loaded.LoadtimeInstrumentationPlugin
  • org.springsource.loaded.ReloadableType
  • org.springsource.loaded.test.CglibProxyTests
  • org.springsource.loaded.test.EnumTests
  • org.springsource.loaded.test.GroovyBenchmarkTests
  • org.springsource.loaded.test.GroovyTests
  • org.springsource.loaded.test.PluginTests
  • org.springsource.loaded.TypeRegistry
  • java.io.FileInputStream
  • java.net.URL
    • 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.