1/*
2 * Copyright (C) 2016 The Android Open Source Project
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
17package dalvik.system;
18
19import junit.framework.TestCase;
20
21import java.lang.invoke.MethodType;
22
23public class EmulatedStackFrameTest extends TestCase {
24
25    public void testReaderWriter_allParamTypes() {
26        EmulatedStackFrame stackFrame = EmulatedStackFrame.create(MethodType.methodType(
27                void.class,
28                new Class<?>[] { boolean.class, char.class, short.class, int.class, long.class,
29                        float.class, double.class, String.class }));
30
31        EmulatedStackFrame.StackFrameWriter writer = new EmulatedStackFrame.StackFrameWriter();
32        writer.attach(stackFrame);
33
34        writer.putNextBoolean(true);
35        writer.putNextChar('a');
36        writer.putNextShort((short) 42);
37        writer.putNextInt(43);
38        writer.putNextLong(56);
39        writer.putNextFloat(42.0f);
40        writer.putNextDouble(52.0);
41        writer.putNextReference("foo", String.class);
42
43        EmulatedStackFrame.StackFrameReader reader = new EmulatedStackFrame.StackFrameReader();
44        reader.attach(stackFrame);
45
46        assertTrue(reader.nextBoolean());
47        assertEquals('a', reader.nextChar());
48        assertEquals((short) 42, reader.nextShort());
49        assertEquals(43, reader.nextInt());
50        assertEquals(56, reader.nextLong());
51        assertEquals(42.0f, reader.nextFloat());
52        assertEquals(52.0, reader.nextDouble());
53        assertEquals("foo", reader.nextReference(String.class));
54    }
55
56    public void testReaderWriter_allReturnTypes() {
57        EmulatedStackFrame stackFrame = EmulatedStackFrame.create(
58                MethodType.methodType(boolean.class));
59
60        EmulatedStackFrame.StackFrameWriter writer = new EmulatedStackFrame.StackFrameWriter();
61        writer.attach(stackFrame).makeReturnValueAccessor();
62
63        EmulatedStackFrame.StackFrameReader reader = new EmulatedStackFrame.StackFrameReader();
64        reader.attach(stackFrame).makeReturnValueAccessor();
65
66        writer.putNextBoolean(true);
67        assertTrue(reader.nextBoolean());
68
69        stackFrame = EmulatedStackFrame.create(MethodType.methodType(char.class));
70        writer.attach(stackFrame).makeReturnValueAccessor();
71        reader.attach(stackFrame).makeReturnValueAccessor();
72
73        writer.putNextChar('a');
74        assertEquals('a', reader.nextChar());
75
76        stackFrame = EmulatedStackFrame.create(MethodType.methodType(short.class));
77        writer.attach(stackFrame).makeReturnValueAccessor();
78        reader.attach(stackFrame).makeReturnValueAccessor();
79
80        writer.putNextShort((short) 52);
81        assertEquals((short) 52, reader.nextShort());
82
83        stackFrame = EmulatedStackFrame.create(MethodType.methodType(int.class));
84        writer.attach(stackFrame).makeReturnValueAccessor();
85        reader.attach(stackFrame).makeReturnValueAccessor();
86        writer.putNextInt(64);
87        assertEquals(64, reader.nextInt());
88
89        stackFrame = EmulatedStackFrame.create(MethodType.methodType(long.class));
90        writer.attach(stackFrame).makeReturnValueAccessor();
91        reader.attach(stackFrame).makeReturnValueAccessor();
92        writer.putNextLong(72);
93        assertEquals(72, reader.nextLong());
94
95        stackFrame = EmulatedStackFrame.create(MethodType.methodType(float.class));
96        writer.attach(stackFrame).makeReturnValueAccessor();
97        reader.attach(stackFrame).makeReturnValueAccessor();
98        writer.putNextFloat(52.0f);
99        assertEquals(52.0f, reader.nextFloat());
100
101        stackFrame = EmulatedStackFrame.create(MethodType.methodType(double.class));
102        writer.attach(stackFrame).makeReturnValueAccessor();
103        reader.attach(stackFrame).makeReturnValueAccessor();
104        writer.putNextDouble(73.0);
105        assertEquals(73.0, reader.nextDouble());
106
107        stackFrame = EmulatedStackFrame.create(MethodType.methodType(String.class));
108        writer.attach(stackFrame).makeReturnValueAccessor();
109        reader.attach(stackFrame).makeReturnValueAccessor();
110        writer.putNextReference("foo", String.class);
111        assertEquals("foo", reader.nextReference(String.class));
112    }
113
114    public void testReaderWriter_wrongTypes() {
115        EmulatedStackFrame stackFrame = EmulatedStackFrame.create(
116                MethodType.methodType(boolean.class, String.class));
117
118        EmulatedStackFrame.StackFrameReader reader = new EmulatedStackFrame.StackFrameReader();
119        reader.attach(stackFrame);
120
121        try {
122            reader.nextInt();
123            fail();
124        } catch (IllegalArgumentException expected) {
125        }
126
127        try {
128            reader.nextDouble();
129            fail();
130        } catch (IllegalArgumentException expected) {
131        }
132
133        assertNull(reader.nextReference(String.class));
134
135        try {
136            reader.nextDouble();
137            fail();
138        } catch (IllegalArgumentException expected) {
139        }
140
141        EmulatedStackFrame.StackFrameWriter writer = new EmulatedStackFrame.StackFrameWriter();
142        writer.attach(stackFrame);
143
144        try {
145            writer.putNextInt(0);
146            fail();
147        } catch (IllegalArgumentException expected) {
148        }
149
150        try {
151            writer.putNextDouble(0);
152            fail();
153        } catch (IllegalArgumentException expected) {
154        }
155
156        writer.putNextReference(null, String.class);
157
158        try {
159            writer.putNextDouble(0);
160            fail();
161        } catch (IllegalArgumentException expected) {
162        }
163    }
164
165    public void testReturnValueReaderWriter_wrongTypes() {
166        EmulatedStackFrame stackFrame = EmulatedStackFrame.create(
167                MethodType.methodType(boolean.class, String.class));
168
169        EmulatedStackFrame.StackFrameReader reader = new EmulatedStackFrame.StackFrameReader();
170        reader.attach(stackFrame);
171        reader.makeReturnValueAccessor();
172
173        try {
174            reader.nextInt();
175            fail();
176        } catch (IllegalArgumentException expected) {
177        }
178
179        // Should succeeed.
180        assertFalse(reader.nextBoolean());
181
182        // The next attempt should fail.
183        try {
184            reader.nextBoolean();
185            fail();
186        } catch (IllegalArgumentException expected) {
187        }
188
189        EmulatedStackFrame.StackFrameWriter writer = new EmulatedStackFrame.StackFrameWriter();
190        writer.attach(stackFrame);
191        writer.makeReturnValueAccessor();
192
193        try {
194            writer.putNextInt(0);
195            fail();
196        } catch (IllegalArgumentException expected) {
197        }
198
199        // Should succeeed.
200        writer.putNextBoolean(true);
201
202        // The next attempt should fail.
203        try {
204            writer.putNextBoolean(false);
205            fail();
206        } catch (IllegalArgumentException expected) {
207        }
208    }
209}
210