1/*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16class UserClassType
17{
18    v : int = 0;
19    constructor (p : int)
20    {
21        this.v = p;
22    }
23
24    override toString() : string {
25        return Int.valueOf(this.v).toString();
26    }
27}
28
29enum UserEnumType 
30{ 
31    Red, 
32    Green, 
33    Blue
34};
35
36let g_array : int [] = [1,2,3];
37let g_array2 : int [] = [11,12,13];
38let g_Array : Array<Int> = new Array<Int>(new Int(4), new Int(5), new Int(6));
39let g_Array2 : Array<Int> = new Array<Int>(new Int(14), new Int(15), new Int(16));
40let g_Object : Object = new Object();
41let g_Object2 : Object = new Object();
42let g_Class : UserClassType = new UserClassType(25);
43let g_Class2 : UserClassType = new UserClassType(250);
44
45
46
47class GlobalClass
48{
49    static s_field : int = 13;
50    field : int = 14;
51
52    static s_method_boxing_local_class() {
53        // predefined value types
54        let l_number : number = 1;
55        let l_byte : byte = 2;
56        let l_short : short = 3;
57        let l_int : int = 4;
58        let l_long : long = 5;
59        let l_float : float = 6.0;
60        let l_double : double = 7.0;
61        let l_boolean : boolean = false;
62        let l_char : char = c'x';
63        
64        // user defined value types
65        let l_enum : UserEnumType = UserEnumType.Red;
66
67        // predefined reference types
68        let l_Number : Number = new Number(11);
69        let l_Byte : Byte = new Byte(12 as byte);
70        let l_Short : Short = new Short(13 as short);
71        let l_Int : Int = new Int(14 as int);
72        let l_Long : Long = new Long(15 as long);
73        let l_Float : Float = new Float(16.0);
74        let l_Double : Double = new Double(17.0);
75        let l_Boolean: Boolean = new Boolean(false);
76        let l_Char : Char = new Char(c'X');
77
78        let l_string : string = "something";
79        let l_String : String = new String("Something");
80        let l_array : int [] = g_array;
81        let l_Array : Array<Int> = g_Array;
82        //let l_bigint : bigint = 20n;
83        //let l_BigInt : BigInt = new BigInt(21n);
84        let l_Object : Object = g_Object;
85
86        // user defined reference types
87        let l_Class : UserClassType = g_Class;
88
89        class LocalClassBoxing
90        {
91            local_field : int = 1000;
92            static local_s_field : int = 2000;
93
94            static local_s_method(lp : int) : void 
95            {
96                assert(lp == 300);
97                assert(LocalClassBoxing.local_s_field == 2000);
98
99                LocalClassBoxing.local_s_field = 5000;
100                assert(LocalClassBoxing.local_s_field == 5000);
101            } 
102
103            local_method(lp : int) : void 
104            {
105                // Parameter
106                assert(lp == 400);
107                // Local class object field
108                assert(this.local_field == 1000);
109                // Local class static field
110                assert(LocalClassBoxing.local_s_field == 5000);
111                // Outer class static field
112                assert(GlobalClass.s_field == 13);
113                // Predefined value types
114                assert(l_number == 1);
115                assert(l_byte == 2);
116                assert(l_short == 3);
117                assert(l_int == 4);
118                assert(l_long == 5);
119                assert(l_float == 6);
120                assert(l_double == 7);
121                assert(l_boolean == false);
122                assert(l_char == c'x');
123                // User defined value type
124                assert(l_enum == UserEnumType.Red);
125                // Predefined reference types
126                assert(l_Number == Number.valueOf(11));
127                assert(l_Byte == Byte.valueOf(12 as byte));
128                assert(l_Short == Short.valueOf(13 as short));
129                assert(l_Int == Int.valueOf(14 as int));
130                assert(l_Long == Long.valueOf(15 as long));
131                assert(l_Float == Float.valueOf(16 as float));
132                assert(l_Double == Double.valueOf(17 as double));
133                assert(l_Boolean == Boolean.valueOf(false));
134                assert(l_Char == Char.valueOf(c'X'));
135                assert(l_string == "something");
136                assert(l_String == "Something");
137                // assert(l_array == g_array);
138                // assert(l_Array == g_Array);
139                assert(l_Object == g_Object);
140                assert(l_Class == g_Class);
141
142                this.local_field = 1100;
143                LocalClassBoxing.local_s_field = 5100;
144
145                l_number = 101;
146                l_byte = 102;
147                l_short = 103;
148                l_int = 104;
149                l_long = 105;
150                l_float = 106.0;
151                l_double = 107.0;
152                l_boolean = true;
153                l_char = c'y';
154                //l_enum = UserEnumType.Green;
155
156                l_Number = new Number(111);
157                l_Byte = new Byte(112 as byte);
158                l_Short = new Short(113 as short);
159                l_Int = new Int(114 as int);
160                l_Long = new Long(115 as long);
161                l_Float = new Float(116.0);
162                l_Double = new Double(117.0);
163                l_Boolean = new Boolean(true);
164                l_Char = new Char(c'Y');
165
166                l_string = "something new";
167                l_String = new String("Something new");
168                l_array = g_array2;
169                l_Array = g_Array2;
170                l_Object = g_Object2;
171                l_Class = g_Class2;
172            }
173        };
174        LocalClassBoxing.local_s_field = 2000;  // due to the jit loop
175        LocalClassBoxing.local_s_method(300);
176
177        let lcb = new LocalClassBoxing();
178        lcb.local_method(400);        
179
180        assert(lcb.local_field == 1100);
181        assert(LocalClassBoxing.local_s_field == 5100);
182        assert(l_number == 101);
183        assert(l_byte == 102);
184        assert(l_short == 103);
185        assert(l_int == 104);
186        assert(l_long == 105);
187        assert(l_float == 106);
188        assert(l_double == 107);
189        assert(l_boolean == true);
190        assert(l_char == c'y');
191        
192        //assert(l_enum == UserEnumType.Green);
193        
194        // Predefined reference types
195        assert(l_Number == Number.valueOf(111));
196        assert(l_Byte == Byte.valueOf(112 as byte));
197        assert(l_Short == Short.valueOf(113 as short));
198        assert(l_Int == Int.valueOf(114 as int));
199        assert(l_Long == Long.valueOf(115 as long));
200        assert(l_Float == Float.valueOf(116 as float));
201        assert(l_Double == Double.valueOf(117 as double));
202        assert(l_Boolean == Boolean.valueOf(true));
203        assert(l_Char == Char.valueOf(c'Y'));
204        assert(l_string == "something new");
205        assert(l_String == "Something new");
206        //assert(l_array == g_array2);
207        //assert(l_Array == g_Array2);
208        assert(l_Object == g_Object2);
209        assert(l_Class == g_Class2);
210    }
211}
212
213
214function main() : int
215{
216    GlobalClass.s_method_boxing_local_class();
217    return 0;
218}
219