blob: aa3cf8665c35a7901fd4f29c2e21c860e54ce6d3 [file] [log] [blame]
Carl Shapiro894d0fa2011-06-30 14:48:49 -07001// Copyright 2011 Google Inc. All Rights Reserved.
Carl Shapiro894d0fa2011-06-30 14:48:49 -07002
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003#include "class_linker.h"
4#include "common_test.h"
5#include "dex_file.h"
6#include "heap.h"
7#include "object.h"
8#include "scoped_ptr.h"
Carl Shapiro894d0fa2011-06-30 14:48:49 -07009
Brian Carlstrom0b138b22011-07-27 15:19:17 -070010#include <stdint.h>
Carl Shapiro894d0fa2011-06-30 14:48:49 -070011#include <stdio.h>
12#include "gtest/gtest.h"
13
14namespace art {
15
Brian Carlstromf734cf52011-08-17 16:28:14 -070016class ObjectTest : public CommonTest {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070017 protected:
Carl Shapirof88c9522011-08-06 15:47:38 -070018 void AssertString(size_t length,
Brian Carlstrom0b138b22011-07-27 15:19:17 -070019 const char* utf8_in,
20 const char* utf16_expected_le,
Carl Shapirof88c9522011-08-06 15:47:38 -070021 uint32_t hash_expected) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070022 uint16_t utf16_expected[length];
Carl Shapirof88c9522011-08-06 15:47:38 -070023 for (size_t i = 0; i < length; i++) {
Brian Carlstrom0b138b22011-07-27 15:19:17 -070024 uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
25 ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
26 utf16_expected[i] = ch;
27 }
28
Jesse Wilson8989d992011-08-02 13:39:42 -070029 String* string = String::AllocFromModifiedUtf8(length, utf8_in);
Carl Shapiro8860c0e2011-08-04 17:36:16 -070030 ASSERT_EQ(length, string->GetLength());
31 ASSERT_TRUE(string->GetCharArray() != NULL);
Jesse Wilsonfd687c52011-08-04 19:27:35 -070032 ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -040033 // strlen is necessary because the 1-character string "\0" is interpreted as ""
Carl Shapirof88c9522011-08-06 15:47:38 -070034 ASSERT_TRUE(string->Equals(utf8_in) || length != strlen(utf8_in));
35 for (size_t i = 0; i < length; i++) {
Jesse Wilsonfd687c52011-08-04 19:27:35 -070036 EXPECT_EQ(utf16_expected[i], string->CharAt(i));
Brian Carlstrom0b138b22011-07-27 15:19:17 -070037 }
Carl Shapiro8860c0e2011-08-04 17:36:16 -070038 EXPECT_EQ(hash_expected, string->GetHashCode());
Brian Carlstrom0b138b22011-07-27 15:19:17 -070039 }
40};
Brian Carlstroma331b3c2011-07-18 17:47:56 -070041
42TEST_F(ObjectTest, IsInSamePackage) {
Carl Shapiro894d0fa2011-06-30 14:48:49 -070043 // Matches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070044 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
45 String::AllocFromModifiedUtf8("Ljava/lang/Class")));
46 EXPECT_TRUE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("LFoo;"),
47 String::AllocFromModifiedUtf8("LBar;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070048
49 // Mismatches
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070050 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
51 String::AllocFromModifiedUtf8("Ljava/io/File;")));
52 EXPECT_FALSE(Class::IsInSamePackage(String::AllocFromModifiedUtf8("Ljava/lang/Object;"),
53 String::AllocFromModifiedUtf8("Ljava/lang/reflect/Method;")));
Carl Shapiro894d0fa2011-06-30 14:48:49 -070054}
55
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070056TEST_F(ObjectTest, AllocObjectArray) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070057 ObjectArray<Object>* oa = class_linker_->AllocObjectArray<Object>(2);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070058 EXPECT_EQ(2, oa->GetLength());
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070059 EXPECT_TRUE(oa->Get(0) == NULL);
60 EXPECT_TRUE(oa->Get(1) == NULL);
61 oa->Set(0, oa);
62 EXPECT_TRUE(oa->Get(0) == oa);
63 EXPECT_TRUE(oa->Get(1) == NULL);
64 oa->Set(1, oa);
65 EXPECT_TRUE(oa->Get(0) == oa);
66 EXPECT_TRUE(oa->Get(1) == oa);
67
Elliott Hughes710a0cb2011-08-16 14:32:37 -070068 Thread* self = Thread::Current();
69 Class* aioobe = class_linker_->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
70
71 EXPECT_TRUE(oa->Get(-1) == NULL);
72 EXPECT_TRUE(self->IsExceptionPending());
73 EXPECT_EQ(aioobe, self->GetException()->GetClass());
74 self->ClearException();
75
76 EXPECT_TRUE(oa->Get(2) == NULL);
77 EXPECT_TRUE(self->IsExceptionPending());
78 EXPECT_EQ(aioobe, self->GetException()->GetClass());
79 self->ClearException();
80
Brian Carlstromf7ed11a2011-08-09 17:55:51 -070081 ASSERT_TRUE(oa->GetClass() != NULL);
82 ASSERT_EQ(2U, oa->GetClass()->NumInterfaces());
83 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/lang/Cloneable;"),
84 oa->GetClass()->GetInterface(0));
85 EXPECT_EQ(class_linker_->FindSystemClass("Ljava/io/Serializable;"),
86 oa->GetClass()->GetInterface(1));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070087}
88
Elliott Hughes68f4fa02011-08-21 10:46:59 -070089TEST_F(ObjectTest, AllocArray) {
90 Class* c = class_linker_->FindSystemClass("[I");
91 Array* a = Array::Alloc(c, 1);
92 ASSERT_TRUE(c == a->GetClass());
93
94 c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
95 a = Array::Alloc(c, 1);
96 ASSERT_TRUE(c == a->GetClass());
97
98 c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
99 a = Array::Alloc(c, 1);
100 ASSERT_TRUE(c == a->GetClass());
101}
102
Elliott Hughes710a0cb2011-08-16 14:32:37 -0700103template<typename ArrayT>
104void TestPrimitiveArray(ClassLinker* cl) {
105 typedef typename ArrayT::ElementType T;
106
107 ArrayT* a = ArrayT::Alloc(2);
108 EXPECT_EQ(2, a->GetLength());
109 EXPECT_EQ(0, a->Get(0));
110 EXPECT_EQ(0, a->Get(1));
111 a->Set(0, T(123));
112 EXPECT_EQ(T(123), a->Get(0));
113 EXPECT_EQ(0, a->Get(1));
114 a->Set(1, T(321));
115 EXPECT_EQ(T(123), a->Get(0));
116 EXPECT_EQ(T(321), a->Get(1));
117
118 Thread* self = Thread::Current();
119 Class* aioobe = cl->FindSystemClass("Ljava/lang/ArrayIndexOutOfBoundsException;");
120
121 EXPECT_EQ(0, a->Get(-1));
122 EXPECT_TRUE(self->IsExceptionPending());
123 EXPECT_EQ(aioobe, self->GetException()->GetClass());
124 self->ClearException();
125
126 EXPECT_EQ(0, a->Get(2));
127 EXPECT_TRUE(self->IsExceptionPending());
128 EXPECT_EQ(aioobe, self->GetException()->GetClass());
129 self->ClearException();
130}
131
132TEST_F(ObjectTest, PrimitiveArray_Boolean_Alloc) {
133 TestPrimitiveArray<BooleanArray>(class_linker_);
134}
135TEST_F(ObjectTest, PrimitiveArray_Byte_Alloc) {
136 TestPrimitiveArray<ByteArray>(class_linker_);
137}
138TEST_F(ObjectTest, PrimitiveArray_Char_Alloc) {
139 TestPrimitiveArray<CharArray>(class_linker_);
140}
141TEST_F(ObjectTest, PrimitiveArray_Double_Alloc) {
142 TestPrimitiveArray<DoubleArray>(class_linker_);
143}
144TEST_F(ObjectTest, PrimitiveArray_Float_Alloc) {
145 TestPrimitiveArray<FloatArray>(class_linker_);
146}
147TEST_F(ObjectTest, PrimitiveArray_Int_Alloc) {
148 TestPrimitiveArray<IntArray>(class_linker_);
149}
150TEST_F(ObjectTest, PrimitiveArray_Long_Alloc) {
151 TestPrimitiveArray<LongArray>(class_linker_);
152}
153TEST_F(ObjectTest, PrimitiveArray_Short_Alloc) {
154 TestPrimitiveArray<ShortArray>(class_linker_);
155}
156
Brian Carlstrom0b138b22011-07-27 15:19:17 -0700157TEST_F(ObjectTest, String) {
158 // Test the empty string.
159 AssertString(0, "", "", 0);
160
161 // Test one-byte characters.
162 AssertString(1, " ", "\x00\x20", 0x20);
163 AssertString(1, "", "\x00\x00", 0);
164 AssertString(1, "\x7f", "\x00\x7f", 0x7f);
165 AssertString(2, "hi", "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
166
167 // Test two-byte characters.
168 AssertString(1, "\xc2\x80", "\x00\x80", 0x80);
169 AssertString(1, "\xd9\xa6", "\x06\x66", 0x0666);
170 AssertString(1, "\xdf\xbf", "\x07\xff", 0x07ff);
171 AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
172
173 // Test three-byte characters.
174 AssertString(1, "\xe0\xa0\x80", "\x08\x00", 0x0800);
175 AssertString(1, "\xe1\x88\xb4", "\x12\x34", 0x1234);
176 AssertString(1, "\xef\xbf\xbf", "\xff\xff", 0xffff);
177 AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
178}
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400179
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700180TEST_F(ObjectTest, StringEqualsUtf8) {
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700181 String* string = String::AllocFromModifiedUtf8("android");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700182 EXPECT_TRUE(string->Equals("android"));
183 EXPECT_FALSE(string->Equals("Android"));
184 EXPECT_FALSE(string->Equals("ANDROID"));
185 EXPECT_FALSE(string->Equals(""));
186 EXPECT_FALSE(string->Equals("and"));
187 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700188
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700189 String* empty = String::AllocFromModifiedUtf8("");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700190 EXPECT_TRUE(empty->Equals(""));
191 EXPECT_FALSE(empty->Equals("a"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400192}
193
194TEST_F(ObjectTest, StringEquals) {
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700195 String* string = String::AllocFromModifiedUtf8("android");
196 EXPECT_TRUE(string->Equals(String::AllocFromModifiedUtf8("android")));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700197 EXPECT_FALSE(string->Equals("Android"));
198 EXPECT_FALSE(string->Equals("ANDROID"));
199 EXPECT_FALSE(string->Equals(""));
200 EXPECT_FALSE(string->Equals("and"));
201 EXPECT_FALSE(string->Equals("androids"));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400202
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700203 String* empty = String::AllocFromModifiedUtf8("");
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700204 EXPECT_TRUE(empty->Equals(""));
205 EXPECT_FALSE(empty->Equals("a"));
206}
207
208TEST_F(ObjectTest, DescriptorCompare) {
209 ClassLinker* linker = class_linker_;
210
Brian Carlstroma663ea52011-08-19 23:33:41 -0700211 scoped_ptr<DexFile> proto1_dex_file(OpenDexFileBase64(kProtoCompareDex, "kProtoCompareDex"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700212 PathClassLoader* class_loader_1 = AllocPathClassLoader(proto1_dex_file.get());
Brian Carlstroma663ea52011-08-19 23:33:41 -0700213 scoped_ptr<DexFile> proto2_dex_file(OpenDexFileBase64(kProtoCompare2Dex, "kProtoCompare2Dex"));
Carl Shapiro8860c0e2011-08-04 17:36:16 -0700214 PathClassLoader* class_loader_2 = AllocPathClassLoader(proto2_dex_file.get());
215
216 Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
217 ASSERT_TRUE(klass1 != NULL);
218 Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2);
219 ASSERT_TRUE(klass2 != NULL);
220
221 Method* m1_1 = klass1->GetVirtualMethod(0);
222 EXPECT_TRUE(m1_1->GetName()->Equals("m1"));
223 Method* m2_1 = klass1->GetVirtualMethod(1);
224 EXPECT_TRUE(m2_1->GetName()->Equals("m2"));
225 Method* m3_1 = klass1->GetVirtualMethod(2);
226 EXPECT_TRUE(m3_1->GetName()->Equals("m3"));
227 Method* m4_1 = klass1->GetVirtualMethod(3);
228 EXPECT_TRUE(m4_1->GetName()->Equals("m4"));
229
230 Method* m1_2 = klass2->GetVirtualMethod(0);
231 EXPECT_TRUE(m1_2->GetName()->Equals("m1"));
232 Method* m2_2 = klass2->GetVirtualMethod(1);
233 EXPECT_TRUE(m2_2->GetName()->Equals("m2"));
234 Method* m3_2 = klass2->GetVirtualMethod(2);
235 EXPECT_TRUE(m3_2->GetName()->Equals("m3"));
236 Method* m4_2 = klass2->GetVirtualMethod(3);
237 EXPECT_TRUE(m4_2->GetName()->Equals("m4"));
238
239 EXPECT_TRUE(m1_1->HasSameNameAndDescriptor(m1_2));
240 EXPECT_TRUE(m1_2->HasSameNameAndDescriptor(m1_1));
241
242 EXPECT_TRUE(m2_1->HasSameNameAndDescriptor(m2_2));
243 EXPECT_TRUE(m2_2->HasSameNameAndDescriptor(m2_1));
244
245 EXPECT_TRUE(m3_1->HasSameNameAndDescriptor(m3_2));
246 EXPECT_TRUE(m3_2->HasSameNameAndDescriptor(m3_1));
247
248 EXPECT_TRUE(m4_1->HasSameNameAndDescriptor(m4_2));
249 EXPECT_TRUE(m4_2->HasSameNameAndDescriptor(m4_1));
Jesse Wilsoncbe9fc02011-07-29 18:59:50 -0400250}
251
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700252
253TEST_F(ObjectTest, StringHashCode) {
Elliott Hughesbfaadc82011-08-18 17:36:58 -0700254 EXPECT_EQ(0U, String::AllocFromModifiedUtf8("")->GetHashCode());
255 EXPECT_EQ(65U, String::AllocFromModifiedUtf8("A")->GetHashCode());
256 EXPECT_EQ(64578U, String::AllocFromModifiedUtf8("ABC")->GetHashCode());
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700257}
258
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700259TEST_F(ObjectTest, InstanceOf) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700260 scoped_ptr<DexFile> dex(OpenDexFileBase64(kXandY, "kXandY"));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700261 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
262 Class* X = class_linker_->FindClass("LX;", class_loader);
263 Class* Y = class_linker_->FindClass("LY;", class_loader);
264 ASSERT_TRUE(X != NULL);
265 ASSERT_TRUE(Y != NULL);
266
267 EXPECT_FALSE(Object::InstanceOf(NULL, X));
268 EXPECT_FALSE(Object::InstanceOf(NULL, Y));
269
270 Object* x = X->NewInstance();
271 Object* y = Y->NewInstance();
272 ASSERT_TRUE(x != NULL);
273 ASSERT_TRUE(y != NULL);
274
275 EXPECT_TRUE(Object::InstanceOf(x, X));
276 EXPECT_FALSE(Object::InstanceOf(x, Y));
277 EXPECT_TRUE(Object::InstanceOf(y, X));
278 EXPECT_TRUE(Object::InstanceOf(y, Y));
279
280 EXPECT_TRUE(x->InstanceOf(X));
281 EXPECT_FALSE(x->InstanceOf(Y));
282 EXPECT_TRUE(y->InstanceOf(X));
283 EXPECT_TRUE(y->InstanceOf(Y));
284}
285
286TEST_F(ObjectTest, IsAssignableFrom) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700287 scoped_ptr<DexFile> dex(OpenDexFileBase64(kXandY, "kXandY"));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700288 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
289 Class* X = class_linker_->FindClass("LX;", class_loader);
290 Class* Y = class_linker_->FindClass("LY;", class_loader);
291
292 EXPECT_TRUE(X->IsAssignableFrom(X));
293 EXPECT_TRUE(X->IsAssignableFrom(Y));
294 EXPECT_FALSE(Y->IsAssignableFrom(X));
295 EXPECT_TRUE(Y->IsAssignableFrom(Y));
296}
297
298TEST_F(ObjectTest, IsAssignableFromArray) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700299 scoped_ptr<DexFile> dex(OpenDexFileBase64(kXandY, "kXandY"));
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700300 PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
301 Class* X = class_linker_->FindClass("LX;", class_loader);
302 Class* Y = class_linker_->FindClass("LY;", class_loader);
303 ASSERT_TRUE(X != NULL);
304 ASSERT_TRUE(Y != NULL);
305
306 Class* YA = class_linker_->FindClass("[LY;", class_loader);
307 Class* YAA = class_linker_->FindClass("[[LY;", class_loader);
308 ASSERT_TRUE(YA != NULL);
309 ASSERT_TRUE(YAA != NULL);
310
311 Class* XAA = class_linker_->FindClass("[[LX;", class_loader);
312 ASSERT_TRUE(XAA != NULL);
313
314 Class* O = class_linker_->FindSystemClass("Ljava/lang/Object;");
315 Class* OA = class_linker_->FindSystemClass("[Ljava/lang/Object;");
316 Class* OAA = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
317 Class* OAAA = class_linker_->FindSystemClass("[[[Ljava/lang/Object;");
318 ASSERT_TRUE(O != NULL);
319 ASSERT_TRUE(OA != NULL);
320 ASSERT_TRUE(OAA != NULL);
321 ASSERT_TRUE(OAAA != NULL);
322
323 Class* S = class_linker_->FindSystemClass("Ljava/io/Serializable;");
324 Class* SA = class_linker_->FindSystemClass("[Ljava/io/Serializable;");
325 Class* SAA = class_linker_->FindSystemClass("[[Ljava/io/Serializable;");
326 ASSERT_TRUE(S != NULL);
327 ASSERT_TRUE(SA != NULL);
328 ASSERT_TRUE(SAA != NULL);
329
330 Class* IA = class_linker_->FindSystemClass("[I");
331 ASSERT_TRUE(IA != NULL);
332
333 EXPECT_TRUE(YAA->IsAssignableFrom(YAA)); // identity
334 EXPECT_TRUE(XAA->IsAssignableFrom(YAA)); // element superclass
335 EXPECT_FALSE(YAA->IsAssignableFrom(XAA));
336 EXPECT_FALSE(Y->IsAssignableFrom(YAA));
337 EXPECT_FALSE(YA->IsAssignableFrom(YAA));
338 EXPECT_TRUE(O->IsAssignableFrom(YAA)); // everything is an Object
339 EXPECT_TRUE(OA->IsAssignableFrom(YAA));
340 EXPECT_TRUE(OAA->IsAssignableFrom(YAA));
341 EXPECT_TRUE(S->IsAssignableFrom(YAA)); // all arrays are Serializable
342 EXPECT_TRUE(SA->IsAssignableFrom(YAA));
343 EXPECT_FALSE(SAA->IsAssignableFrom(YAA)); // unless Y was Serializable
344
345 EXPECT_FALSE(IA->IsAssignableFrom(OA));
346 EXPECT_FALSE(OA->IsAssignableFrom(IA));
347 EXPECT_TRUE(O->IsAssignableFrom(IA));
348}
349
Elliott Hughescdf53122011-08-19 15:46:09 -0700350TEST_F(ObjectTest, FindInstanceField) {
351 String* s = String::AllocFromModifiedUtf8("ABC");
352 ASSERT_TRUE(s != NULL);
353 Class* c = s->GetClass();
354 ASSERT_TRUE(c != NULL);
355
356 // Wrong type.
357 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "J") == NULL);
358 EXPECT_TRUE(c->FindInstanceField("count", "J") == NULL);
359
360 // Wrong name.
361 EXPECT_TRUE(c->FindDeclaredInstanceField("Count", "I") == NULL);
362 EXPECT_TRUE(c->FindInstanceField("Count", "I") == NULL);
363
364 // Right name and type.
365 Field* f1 = c->FindDeclaredInstanceField("count", "I");
366 Field* f2 = c->FindInstanceField("count", "I");
367 EXPECT_TRUE(f1 != NULL);
368 EXPECT_TRUE(f2 != NULL);
369 EXPECT_EQ(f1, f2);
370
371 // TODO: check that s.count == 3.
372
373 // Ensure that we handle superclass fields correctly...
374 c = class_linker_->FindSystemClass("Ljava/lang/StringBuilder;");
375 ASSERT_TRUE(c != NULL);
376 // No StringBuilder.count...
377 EXPECT_TRUE(c->FindDeclaredInstanceField("count", "I") == NULL);
378 // ...but there is an AbstractStringBuilder.count.
379 EXPECT_TRUE(c->FindInstanceField("count", "I") != NULL);
380}
381
382TEST_F(ObjectTest, FindStaticField) {
383 String* s = String::AllocFromModifiedUtf8("ABC");
384 ASSERT_TRUE(s != NULL);
385 Class* c = s->GetClass();
386 ASSERT_TRUE(c != NULL);
387
388 // Wrong type.
389 EXPECT_TRUE(c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
390 EXPECT_TRUE(c->FindStaticField("CASE_INSENSITIVE_ORDER", "I") == NULL);
391
392 // Wrong name.
393 EXPECT_TRUE(c->FindDeclaredStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
394 EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
395
396 // Right name and type.
397 Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
398 Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
399 EXPECT_TRUE(f1 != NULL);
400 EXPECT_TRUE(f2 != NULL);
401 EXPECT_EQ(f1, f2);
402
403 // TODO: test static fields via superclasses.
404 // TODO: test static fields via interfaces.
405 // TODO: test that interfaces trump superclasses.
406}
407
Carl Shapiro894d0fa2011-06-30 14:48:49 -0700408} // namespace art