OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
| 5 #include "vm/allocation.h" |
5 #include "platform/assert.h" | 6 #include "platform/assert.h" |
6 #include "vm/allocation.h" | |
7 #include "vm/longjump.h" | 7 #include "vm/longjump.h" |
8 #include "vm/unit_test.h" | 8 #include "vm/unit_test.h" |
9 | 9 |
10 namespace dart { | 10 namespace dart { |
11 | 11 |
12 class TestValueObject : public ValueObject { | 12 class TestValueObject : public ValueObject { |
13 public: | 13 public: |
14 explicit TestValueObject(int* ptr) : ptr_(ptr) { | 14 explicit TestValueObject(int* ptr) : ptr_(ptr) { |
15 EXPECT_EQ(1, *ptr_); | 15 EXPECT_EQ(1, *ptr_); |
16 *ptr_ = 2; | 16 *ptr_ = 2; |
17 } | 17 } |
18 | 18 |
19 virtual ~TestValueObject() { | 19 virtual ~TestValueObject() { |
20 EXPECT_EQ(3, *ptr_); | 20 EXPECT_EQ(3, *ptr_); |
21 *ptr_ = 4; | 21 *ptr_ = 4; |
22 } | 22 } |
23 | 23 |
24 int value() const { return *ptr_; } | 24 int value() const { return *ptr_; } |
25 virtual int GetId() const { return 3; } | 25 virtual int GetId() const { return 3; } |
26 | 26 |
27 private: | 27 private: |
28 int* ptr_; | 28 int* ptr_; |
29 }; | 29 }; |
30 | 30 |
31 | |
32 class TestStackResource : public StackResource { | 31 class TestStackResource : public StackResource { |
33 public: | 32 public: |
34 explicit TestStackResource(int* ptr) | 33 explicit TestStackResource(int* ptr) |
35 : StackResource(Thread::Current()), ptr_(ptr) { | 34 : StackResource(Thread::Current()), ptr_(ptr) { |
36 EXPECT_EQ(1, *ptr_); | 35 EXPECT_EQ(1, *ptr_); |
37 *ptr_ = 2; | 36 *ptr_ = 2; |
38 } | 37 } |
39 | 38 |
40 ~TestStackResource() { | 39 ~TestStackResource() { |
41 EXPECT_EQ(6, *ptr_); | 40 EXPECT_EQ(6, *ptr_); |
42 *ptr_ = 7; | 41 *ptr_ = 7; |
43 } | 42 } |
44 | 43 |
45 int value() const { return *ptr_; } | 44 int value() const { return *ptr_; } |
46 virtual int GetId() const { return 3; } | 45 virtual int GetId() const { return 3; } |
47 | 46 |
48 private: | 47 private: |
49 int* ptr_; | 48 int* ptr_; |
50 }; | 49 }; |
51 | 50 |
52 | |
53 class TestStackedStackResource : public StackResource { | 51 class TestStackedStackResource : public StackResource { |
54 public: | 52 public: |
55 explicit TestStackedStackResource(int* ptr) | 53 explicit TestStackedStackResource(int* ptr) |
56 : StackResource(Thread::Current()), ptr_(ptr) { | 54 : StackResource(Thread::Current()), ptr_(ptr) { |
57 EXPECT_EQ(3, *ptr_); | 55 EXPECT_EQ(3, *ptr_); |
58 *ptr_ = 4; | 56 *ptr_ = 4; |
59 } | 57 } |
60 | 58 |
61 ~TestStackedStackResource() { | 59 ~TestStackedStackResource() { |
62 EXPECT_EQ(5, *ptr_); | 60 EXPECT_EQ(5, *ptr_); |
63 *ptr_ = 6; | 61 *ptr_ = 6; |
64 } | 62 } |
65 | 63 |
66 int value() const { return *ptr_; } | 64 int value() const { return *ptr_; } |
67 | 65 |
68 private: | 66 private: |
69 int* ptr_; | 67 int* ptr_; |
70 }; | 68 }; |
71 | 69 |
72 | |
73 static void StackAllocatedDestructionHelper(int* ptr) { | 70 static void StackAllocatedDestructionHelper(int* ptr) { |
74 TestValueObject stacked(ptr); | 71 TestValueObject stacked(ptr); |
75 EXPECT_EQ(2, *ptr); | 72 EXPECT_EQ(2, *ptr); |
76 *ptr = 3; | 73 *ptr = 3; |
77 } | 74 } |
78 | 75 |
79 | |
80 VM_UNIT_TEST_CASE(StackAllocatedDestruction) { | 76 VM_UNIT_TEST_CASE(StackAllocatedDestruction) { |
81 int data = 1; | 77 int data = 1; |
82 StackAllocatedDestructionHelper(&data); | 78 StackAllocatedDestructionHelper(&data); |
83 EXPECT_EQ(4, data); | 79 EXPECT_EQ(4, data); |
84 } | 80 } |
85 | 81 |
86 | |
87 static void StackAllocatedLongJumpHelper(int* ptr, LongJumpScope* jump) { | 82 static void StackAllocatedLongJumpHelper(int* ptr, LongJumpScope* jump) { |
88 TestValueObject stacked(ptr); | 83 TestValueObject stacked(ptr); |
89 EXPECT_EQ(2, *ptr); | 84 EXPECT_EQ(2, *ptr); |
90 *ptr = 3; | 85 *ptr = 3; |
91 const Error& error = Error::Handle(LanguageError::New( | 86 const Error& error = Error::Handle(LanguageError::New( |
92 String::Handle(String::New("StackAllocatedLongJump")))); | 87 String::Handle(String::New("StackAllocatedLongJump")))); |
93 jump->Jump(1, error); | 88 jump->Jump(1, error); |
94 UNREACHABLE(); | 89 UNREACHABLE(); |
95 } | 90 } |
96 | 91 |
97 | |
98 TEST_CASE(StackAllocatedLongJump) { | 92 TEST_CASE(StackAllocatedLongJump) { |
99 LongJumpScope jump; | 93 LongJumpScope jump; |
100 int data = 1; | 94 int data = 1; |
101 if (setjmp(*jump.Set()) == 0) { | 95 if (setjmp(*jump.Set()) == 0) { |
102 StackAllocatedLongJumpHelper(&data, &jump); | 96 StackAllocatedLongJumpHelper(&data, &jump); |
103 UNREACHABLE(); | 97 UNREACHABLE(); |
104 } | 98 } |
105 EXPECT_EQ(3, data); | 99 EXPECT_EQ(3, data); |
106 } | 100 } |
107 | 101 |
108 | |
109 static void StackedStackResourceDestructionHelper(int* ptr) { | 102 static void StackedStackResourceDestructionHelper(int* ptr) { |
110 TestStackedStackResource stacked(ptr); | 103 TestStackedStackResource stacked(ptr); |
111 EXPECT_EQ(4, *ptr); | 104 EXPECT_EQ(4, *ptr); |
112 *ptr = 5; | 105 *ptr = 5; |
113 } | 106 } |
114 | 107 |
115 | |
116 static void StackResourceDestructionHelper(int* ptr) { | 108 static void StackResourceDestructionHelper(int* ptr) { |
117 TestStackResource stacked(ptr); | 109 TestStackResource stacked(ptr); |
118 EXPECT_EQ(2, *ptr); | 110 EXPECT_EQ(2, *ptr); |
119 *ptr = 3; | 111 *ptr = 3; |
120 StackedStackResourceDestructionHelper(ptr); | 112 StackedStackResourceDestructionHelper(ptr); |
121 EXPECT_EQ(6, *ptr); | 113 EXPECT_EQ(6, *ptr); |
122 // Do not set data because the LongJump version does not return control here. | 114 // Do not set data because the LongJump version does not return control here. |
123 } | 115 } |
124 | 116 |
125 | |
126 TEST_CASE(StackResourceDestruction) { | 117 TEST_CASE(StackResourceDestruction) { |
127 int data = 1; | 118 int data = 1; |
128 StackResourceDestructionHelper(&data); | 119 StackResourceDestructionHelper(&data); |
129 EXPECT_EQ(7, data); | 120 EXPECT_EQ(7, data); |
130 } | 121 } |
131 | 122 |
132 | |
133 static void StackedStackResourceLongJumpHelper(int* ptr, LongJumpScope* jump) { | 123 static void StackedStackResourceLongJumpHelper(int* ptr, LongJumpScope* jump) { |
134 TestStackedStackResource stacked(ptr); | 124 TestStackedStackResource stacked(ptr); |
135 EXPECT_EQ(4, *ptr); | 125 EXPECT_EQ(4, *ptr); |
136 *ptr = 5; | 126 *ptr = 5; |
137 const Error& error = Error::Handle(LanguageError::New( | 127 const Error& error = Error::Handle(LanguageError::New( |
138 String::Handle(String::New("StackedStackResourceLongJump")))); | 128 String::Handle(String::New("StackedStackResourceLongJump")))); |
139 jump->Jump(1, error); | 129 jump->Jump(1, error); |
140 UNREACHABLE(); | 130 UNREACHABLE(); |
141 } | 131 } |
142 | 132 |
143 | |
144 static void StackResourceLongJumpHelper(int* ptr, LongJumpScope* jump) { | 133 static void StackResourceLongJumpHelper(int* ptr, LongJumpScope* jump) { |
145 TestStackResource stacked(ptr); | 134 TestStackResource stacked(ptr); |
146 EXPECT_EQ(2, *ptr); | 135 EXPECT_EQ(2, *ptr); |
147 *ptr = 3; | 136 *ptr = 3; |
148 StackedStackResourceLongJumpHelper(ptr, jump); | 137 StackedStackResourceLongJumpHelper(ptr, jump); |
149 UNREACHABLE(); | 138 UNREACHABLE(); |
150 } | 139 } |
151 | 140 |
152 | |
153 TEST_CASE(StackResourceLongJump) { | 141 TEST_CASE(StackResourceLongJump) { |
154 LongJumpScope* base = Thread::Current()->long_jump_base(); | 142 LongJumpScope* base = Thread::Current()->long_jump_base(); |
155 { | 143 { |
156 LongJumpScope jump; | 144 LongJumpScope jump; |
157 int data = 1; | 145 int data = 1; |
158 if (setjmp(*jump.Set()) == 0) { | 146 if (setjmp(*jump.Set()) == 0) { |
159 StackResourceLongJumpHelper(&data, &jump); | 147 StackResourceLongJumpHelper(&data, &jump); |
160 UNREACHABLE(); | 148 UNREACHABLE(); |
161 } | 149 } |
162 EXPECT_EQ(7, data); | 150 EXPECT_EQ(7, data); |
163 } | 151 } |
164 ASSERT(base == Thread::Current()->long_jump_base()); | 152 ASSERT(base == Thread::Current()->long_jump_base()); |
165 } | 153 } |
166 | 154 |
167 } // namespace dart | 155 } // namespace dart |
OLD | NEW |