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_not_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 LocalClassNotBoxing
90        {
91            local_field : int = 100;
92            static local_s_field : int = 200;
93
94            static local_s_method(lp : int) : void 
95            {
96                assert(lp == 30);
97                assert(LocalClassNotBoxing.local_s_field == 200);
98            } 
99
100            local_method(lp : int) : void 
101            {
102                // Parameter
103                assert(lp == 40);
104                // Local class object field
105                assert(this.local_field == 100);
106                // Local class static field
107                assert(LocalClassNotBoxing.local_s_field == 200);
108                // Predefined value types
109                assert(l_number == 1);
110                assert(l_byte == 2);
111                assert(l_short == 3);
112                assert(l_int == 4);
113                assert(l_long == 5);
114                assert(l_float == 6);
115                assert(l_double == 7);
116                assert(l_boolean == false);
117                assert(l_char == c'x');
118                // User defined value type
119                assert(l_enum == UserEnumType.Red);
120                // Predefined reference types
121                assert(l_Number == Number.valueOf(11));
122                assert(l_Byte == Byte.valueOf(12 as byte));
123                assert(l_Short == Short.valueOf(13 as short));
124                assert(l_Int == Int.valueOf(14 as int));
125                assert(l_Long == Long.valueOf(15 as long));
126                assert(l_Float == Float.valueOf(16 as float));
127                assert(l_Double == Double.valueOf(17 as double));
128                assert(l_Boolean == Boolean.valueOf(false));
129                assert(l_Char == Char.valueOf(c'X'));
130                assert(l_string == "something");
131                assert(l_String == "Something");
132                assert(l_array == g_array);
133                assert(l_Array == g_Array);
134                assert(l_Object == g_Object);
135                assert(l_Class == g_Class);
136            }
137        };
138
139        LocalClassNotBoxing.local_s_method(30);
140
141        let lc = new LocalClassNotBoxing();
142        lc.local_method(40);
143    }
144}
145
146
147function main() : int
148{
149    GlobalClass.s_method_not_boxing_local_class();
150    return 0;
151}
152