• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2022 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
16/*
17 * @tc.name:stubbuilder
18 * @tc.desc:test stubbuilder
19 * @tc.type: FUNC
20 * @tc.require: issueI5NO8G
21 */
22
23/*
24*    ZExtInt8ToPtr(); IntPtr(); Int8(); PtrMul(); Int8LSR(); Int8And(); Store(); Load();
25*    ReadInst4_0(); ReadInst4_1(); GetVregValue(); SetVregValue();
26*/
27                      /**************HandleMovV4V4****************/
28
29{
30    var fun = function(parameter) {
31        return parameter;
32    }
33
34    var call = fun(100);
35    assert_equal(call,100);
36}
37
38/*
39*   ZExtInt16ToPtr(); Int16(); ZExtInt8ToInt16();  Int16LSL(); Int16Add();
40*
41*   ReadInst16_0(); ReadInst16_2(); GetVregValue(); SetVregValue(); ReadInst8_0(); ReadInst8_1(); ReadInst8_2(); ReadInst8_3();
42*/
43                      /**************HandleMovV16V16****************/
44
45{
46    var fun = function(pmt1, pmt2, pmt3, pmt4, pmt5, pmt6, pmt7, pmt8, pmt9, pmt10) {
47        let sum = pmt1 + pmt2 + pmt3 + pmt4 + pmt5 + pmt6 + pmt7 + pmt8 + pmt9 + pmt10;
48        return sum;
49    }
50
51    var call = fun(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
52    assert_equal(call,55);
53}
54
55/*
56*    IntToTaggedPtr(); ZExtInt8ToInt32(); Int32LSL(); Int32(); Int32Add();
57*    ReadInst32_0();
58*/
59                      /**************HandleLdaiImm32****************/
60{
61    var fun = function() {
62        let a = 20;
63        return a;
64    }
65    var iter = fun();
66    assert_equal(iter,20);
67}
68
69/*
70*    SExtInt32ToPtr(); SExtInt1ToInt32();
71*    ReadInstSigned8_0();
72*/
73                      /**************HandleJmpImm8****************/
74{
75    var fun = function() {
76    	let expectres = "";
77        try {
78            expectres = "foo";
79            assert_equal(expectres,"foo");
80          } finally {
81            expectres = "bar";
82        }
83        assert_equal(expectres,"bar");
84    }
85    var iter = fun();
86}
87
88/*
89*    CastInt64ToFloat64(); DoubleToTaggedDoublePtr(); ZExtInt8ToInt64(); Int64(); Int64LSL(); Int64Add();
90*    CastDoubleToInt64(); Int64ToTaggedPtr();
91*    ReadInst64_0(); ReadInst8_7(); ReadInst8_6(); ReadInst8_5(); ReadInst8_4(); ReadInst8_3(); ReadInst8_2(); ReadInst8_1();
92*    ReadInst8_0();
93*/
94                      /**************HandleFldaiImm64****************/
95{
96    {
97        var fun = function() {
98            let a = 2.55;
99            return a;
100        }
101        var iter = fun();
102        assert_equal(iter,2.55);
103    }
104}
105
106/*
107*    TaggedIsInt(); TaggedCastToInt32(); Int32Equal(); TaggedIsDouble(); TaggedCastToDouble(); Double(); DoubleAdd();
108*    CallRuntime(); Int64And(); Int64Equal(); TaggedCastToInt64(); ChangeInt64ToInt32(); BoolNot(); TaggedIsNumber();
109*    BoolAnd(); ChangeTaggedPointerToInt64(); Int64Sub(); SavePcIfNeeded(); TaggedIsObject(); Argument(); PtrSub();
110*/
111                      /**************HandleIncImm8****************/
112{
113    var fun = function() {
114        let a = 10;
115        return ++a;
116    }
117    var iter = fun();
118    assert_equal(iter,11);
119}
120
121/*
122*    TaggedIsException(); TaggedIsUndefined(); Int32Not(); TruncPtrToInt32(); IntPtrEqual(); CallNGCRuntime(); Equal();
123*    TruncInt64ToInt32();
124*/
125                      /**************HandleSuspendgeneratorV8****************/
126{
127    var fun = function *() {
128        yield 888;
129    }
130
131    let iter = fun();
132    assert_equal(iter.next().value,888);
133}
134
135/*
136*    ZExtInt16ToInt32(); Int16Sub(); TaggedIsHeapObject(); IsBase(); IsJSFunction(); IsConstructor(); IsJSHClass(); GetObjectType();
137*    JSCallDispatch(); ChangeInt32ToIntPtr(); Int16ToTaggedInt(); HasPendingException(); GetMethodFromJSFunction();
138*    Int32LessThanOrEqual(); Int32LSR(); Int32And(); Int32GreaterThanOrEqual(); LoadHClass(); Int32NotEqual(); ZExtInt32ToInt64();
139*    SExtInt16ToInt64(); Int64Or(); Int64NotEqual(); IsJSFunctionBase();
140*
141*/
142                      /**************HandleNewobjrangeImm8Imm8V8****************/
143{
144    class Parent {
145        constructor(name, age) {
146            this.name = name;
147            this.age = age;
148        }
149        sayName() {
150            assert_equal(this.name,"echo");
151            assert_equal(this.age,26);
152        }
153    };
154    const child = new Parent('echo', 26);
155    child.sayName(); //echo
156}
157
158/*
159*    Int32Sub(); DoubleSub();
160*
161*/
162                      /**************HandleDecImm8****************/
163{
164    var fun = function() {
165        let a = 10;
166        return --a;
167    }
168    var iter = fun();
169    assert_equal(iter,9);
170}
171
172/*
173*    FastStrictEqual(); ChangeInt32ToFloat64(); DoubleIsNAN(); BoolOr(); DoubleEqual(); BothAreString(); IsUtf16String();
174*    ZExtInt1ToInt32(); GetLengthFromString(); GetHashcodeFromString(); CallNGCRuntime(); TaggedIsBigInt();
175*    BothAreString();
176*/
177                      /**************HandleStrictnoteqImm8V8****************/
178{
179    var fun = function(parameter1, parameter2) {
180        if (parameter1 === parameter2) {
181            return parameter2;
182        }
183        return parameter1;
184    }
185    var iter = fun(10n, 5);
186    assert_equal(Number(iter),10);
187}
188
189/*
190*   DoubleToInt(); Int32Xor(); ChangeFloat64ToInt32(); Int64LSR(); Int32LessThan();
191*
192*/
193                      /**************HandleXor2Imm8V8****************/
194{
195    var fun = function(parameter1, parameter2) {
196        if (parameter1 != parameter2) {
197            return parameter1^parameter2;
198        }
199        return parameter2;
200    }
201    var iter = fun(10, 5);
202    assert_equal(iter,15);
203}
204
205/*
206*   Int32ASR();
207*
208*/
209                      /**************HandleAshr2Imm8V8****************/
210{
211    var fun = function(parameter1, parameter2) {
212        if (parameter1 != parameter2) {
213            return parameter1 >> parameter2;
214        }
215        return parameter2;
216    }
217    var iter = fun(10, 1);
218    assert_equal(iter,5);
219}
220
221/*
222*  TaggedIsNumeric();
223*
224*/
225                      /**************HandleTonumericImm8****************/
226{
227    var fun = function() {
228        let parameter = 5n;
229        return parameter++;
230    }
231    var iter = fun();
232    assert_equal(Number(iter),5);
233}
234
235/*
236*  FastMul(); TaggedIsHole(); FastAddSubAndMul(); Int64GreaterThan(); Int64LessThan(); FastBinaryOp();
237*
238*/
239                      /**************HandleMul2Imm8V8****************/
240{
241    var fun = function() {
242        let parameter1 = 5.5;
243        let parameter2 = 2;
244        return parameter1 * parameter2;
245    }
246    var iter = fun();
247    assert_equal(iter,11);
248}
249
250/*
251*  GetPropertyByIndex(); IntToTaggedInt(); TaggedFalse(); Undefined(); IsSpecialIndexedObj(); IsFastTypeArray();
252*  IsSpecialContainer(); GetContainerProperty(); GetElementsArray(); IsDictionaryElement(); GetLengthOfTaggedArray();
253*  Int32UnsignedLessThan(); GetValueFromTaggedArray(); TaggedIsNotHole(); FindElementFromNumberDictionary();
254*  CallGetterHelper(); GetPrototypeFromHClass(); SExtInt32ToInt64(); Int32GreaterThan(); IsAccessor(); JSAPIContainerGet();
255*/
256                      /**************HandleLdobjbyindexImm8Imm16****************/
257{
258    var fun = function() {
259        let array = new Array(2);
260        array[0] = 12;
261        array[1] = 18;
262        return array[1];
263    }
264    var iter = fun();
265    assert_equal(iter,18);
266}
267
268/*
269*  FastEqual(); TaggedIsUndefinedOrNull(); TaggedIsBoolean(); TaggedIsSpecial();
270*
271*/
272                      /**************HandleEqImm8V8****************/
273{
274    var fun = function(parameter1, parameter2) {
275        if (parameter1 == parameter2) {
276            return parameter1;
277        }
278        return parameter2;
279    }
280    var iter = fun(10, 10);
281    assert_equal(iter,10);
282}
283
284/*
285*  FastMod(); Int32Mod(); DoubleIsINF();
286*
287*/
288                      /**************HandleMod2Imm8V8****************/
289{
290    var fun = function(parameter1, parameter2) {
291        let result = parameter1 % parameter2;
292        return result;
293    }
294    var iter = fun(55, 10);
295    assert_equal(iter,5);
296}
297
298/*
299*  FastTypeOf(); GetGlobalConstantOffset(); TaggedIsTrue(); TaggedIsFalse(); TaggedIsNull(); IsString(); IsSymbol(); IsCallable();
300*  TaggedObjectIsBigInt();  Int32Mul(); Int64Mul();
301*/
302                      /**************HandleTypeofImm8****************/
303{
304    var fun = function(parameter1, parameter2) {
305        let result = parameter1 % parameter2;
306        return typeof(result);
307    }
308    var iter = fun(55, 10);
309    assert_equal(iter,"number");
310}
311
312/*
313*  TaggedGetInt(); DoubleLessThan(); TaggedTrue();
314*
315*/
316                      /**************HandleLessImm8V8****************/
317{
318    var fun = function(parameter1, parameter2) {
319        if (parameter1 < parameter2) {
320            return parameter1;
321        };
322        return parameter2;
323    }
324    var iter = fun(55, 11);
325    assert_equal(iter,11);
326}
327
328/*
329*  DoubleLessThanOrEqual();
330*
331*/
332                      /**************HandleLesseqImm8V8****************/
333{
334    var fun = function(parameter1, parameter2) {
335        if (parameter1 <= parameter2) {
336            return parameter1;
337        };
338        return parameter2;
339    }
340    var iter = fun(5, 11);
341    assert_equal(iter,5);
342}
343
344/*
345*  DoubleGreaterThan();
346*
347*/
348                      /**************HandleGreaterImm8V8****************/
349{
350    var fun = function(parameter1, parameter2) {
351        if (parameter1 > parameter2) {
352            return parameter1;
353        };
354        return parameter2;
355    }
356    var iter = fun(5, 11);
357    assert_equal(iter,11);
358}
359
360/*
361*  DoubleGreaterThanOrEqual();
362*
363*/
364                      /**************HandleGreatereqImm8V8****************/
365{
366    var fun = function(parameter1, parameter2) {
367        if (parameter1 >= parameter2) {
368            return parameter1;
369        };
370        return parameter2;
371    }
372    var iter = fun(5, 9);
373    assert_equal(iter,9);
374}
375
376/*
377*  Int32UnsignedGreaterThan(); ChangeUInt32ToFloat64();
378*
379*/
380                      /**************HandleShr2Imm8V8****************/
381{
382    var fun = function(parameter1, parameter2) {
383        if (parameter1 >> parameter2) {
384            return parameter1;
385        };
386        return parameter2;
387    }
388    var iter = fun(5, 1);
389    assert_equal(iter,5);
390}
391
392/*
393*  SetPropertyByIndex(); LoopBegin(); Hole(); SetValueToTaggedArray(); IsExtensible(); Exception();
394*
395*/
396                      /**************HandleStobjbyindexImm8V8Imm16****************/
397{
398    var fun = function() {
399
400        var myarray=new Array();
401        return myarray[0]=66;
402    }
403    var iter = fun();
404    assert_equal(iter,66);
405}
406
407/*
408*  FastDiv(); Int64Xor(); DoubleDiv();
409*
410*/
411                      /**************HandleDiv2Imm8V8****************/
412{
413    var fun = function(parameter1, parameter2) {
414        let result = parameter1 / parameter2;
415        return result;
416    }
417    var iter = fun(55, 10);
418    assert_equal(iter,5.5);
419}
420
421/*
422*  IsCallableFromBitField(); GetCallFieldFromMethod(); DispatchBuiltins(); IsClassConstructorFromBitField(); ConstructorCheck();
423*  SaveJumpSizeIfNeeded(); TaggedObjectIsEcmaObject();
424*/
425                      /**************HandleNewobjrangeImm8Imm8V8****************/
426{
427    var fun = function() {
428        let func = new Object();
429        func.name = "don";
430        return func.name;
431    }
432    var iter = fun();
433    assert_equal(iter,"don");
434}
435
436/*
437*  FastAdd();
438*
439*/
440                      /**************HandleAdd2Imm8V8****************/
441{
442    var fun = function(parameter1, parameter2) {
443
444        return parameter1 + parameter2;
445    }
446    var iter = fun(10, 10);
447    assert_equal(iter,20);
448}
449
450/*
451*  FastSub();
452*
453*/
454                      /**************HandleSub2Imm8V8****************/
455{
456    var fun = function(parameter1, parameter2) {
457
458        return parameter1 - parameter2;
459    }
460    var iter = fun(10, 10);
461    assert_equal(iter,0);
462}
463
464/*
465*  FastToBoolean();
466*
467*/
468                      /**************HandleIsfalse****************/
469{
470    var fun = function(parameter1, parameter2) {
471
472        if ((parameter1 == 0) || (parameter2 > 0)) {
473            return parameter1;
474        }
475        return parameter2;
476    }
477    var iter = fun(1, 10);
478    assert_equal(iter,1);
479}
480
481/*
482*  Null();
483*
484*/
485                      /**************HandleLdnull****************/
486{
487    var fun = function() {
488
489        let par = null;
490        return undefined;
491    }
492    var iter = fun();
493    assert_equal(iter,undefined);
494}
495
496/*
497*  LoopEnd(); GetPropertiesFromLexicalEnv();
498*
499*/
500                      /**************HandleLdlexvarImm4Imm4****************/
501{
502    function Module() {
503        function f(a) {
504          a = a | 0;
505          a = funTable[a & 0](a | 0) | 0;
506          return a | 0;
507        }
508        function g() {
509          return 2.3;
510        }
511        var funTable = [ g ];
512        return { f:f };
513      }
514      assert_equal(Module().f(),2);
515}
516
517/*
518*  Int32Or();
519*
520*/
521                      /**************HandleOr2Imm8V8****************/
522{
523    function Module() {
524        function f(a) {
525          a = a | 0;
526          var b = 0;
527          b = (a + 23) | 0;
528          return b;
529        }
530        return { f:f };
531      }
532      assert_equal(Module().f(),23);
533}
534
535/*
536*  GetPropertyByValue();
537*/
538                      /**************HandleLdobjbyvalueImm16V8****************/
539{
540    var obj = {name1:"bom", 2:"arm"};
541    var v1 = obj.name1;
542    var v3 = obj[2];
543    var key = "name1";
544    var v4 = obj.key;
545    var v5 = obj[key];
546    assert_equal(v1,"bom");
547    assert_equal(v3,"arm");
548    assert_equal(v4,undefined);
549    assert_equal(v5,"bom");
550}
551
552/*
553*  Int8ToTaggedInt(); SExtInt8ToInt64();
554*/
555                      /**************HandleThrowIfsupernotcorrectcallPrefImm16****************/
556{
557    class A {
558        constructor() {
559        }
560    }
561
562    class B extends A {
563        constructor(name, age) {
564          super();
565          this.name = name;
566          this.age = age;
567        }
568        sayName() {
569            assert_equal(this.name,"echo");
570            assert_equal(this.age,19);
571        }
572    }
573    new A();
574    const people = new B("echo", 19);
575    people.sayName();
576}
577
578/*
579*  SetPropertyByName(); SetTypeArrayPropertyByName(); CallSetterHelper(); ShouldCallSetter(); IsWritable(); UpdateValueInDict();
580*  AddPropertyByName(); SetHasConstructorCondition(); SetHasConstructorToHClass(); SetPropertyInlinedProps(); SetOffsetFieldInPropAttr();
581*  SetIsInlinePropsFieldInPropAttr(); JSHClassAddProperty(); IsDictionaryMode(); SetPropertiesArray(); SetDictionaryOrderFieldInPropAttr();
582*  ComputeNonInlinedFastPropsCapacity;
583*/
584                      /**************HandleStobjbynameImm8Id16V8****************/
585{
586    var obj1 = {"qq":10};
587    var obj2={"mm":2,"nn":3};
588    var obj3={"xx":1,"yy":5};
589    obj1.field1 = obj2;
590    obj1.field2 = obj3;
591    var assertObj = {
592    	"qq": 10,
593    	"field1": {
594    		"mm": 2,
595    		"nn": 3
596    		},
597    	"field2": {
598    		"xx": 1,
599    		"yy": 5
600    		}
601    	}
602    assert_equal(JSON.stringify(obj1),JSON.stringify(assertObj));
603
604}
605
606/**************HandleGetnextpropnameV8****************/
607{
608    var fun = function() {
609        let array = [1, 8, 6, 9], arr;
610        let expectedValues = [1, 8, 6, 9]; // 预期的输出值
611        let index = 0;
612        for (arr in array) {
613            assert_equal(expectedValues[index],array[arr]);
614            index++;
615        };
616        return undefined;
617    }
618    var iter = fun();
619    assert_equal(iter,undefined);
620}
621
622/**************HandleDeprecatedTonumberPrefV8****************/
623{
624    function Module(stdlib, foreign, heap) {
625        var x = +stdlib.x;
626    }
627    assert_equal(Module(this, { x:0 }),undefined);
628}
629
630/**************HandleIsinImm8V8****************/
631{
632    function Person() {
633    };
634    Person.prototype.name = "hello";
635    Person.prototype.age = "12";
636    Person.prototype.sayName = function(){alert(this.name);};
637
638    function hasPrototypeProperty(object, name){
639        return !object.hasOwnProperty(name) && (name in object);
640    };
641    var p1 = new Person();
642    assert_equal(hasPrototypeProperty(p1,"name"),true);
643    p1.name = "nn";
644    assert_equal(hasPrototypeProperty(p1,"name"),false);
645}
646
647/**************HandleInstanceofImm8V8****************/
648{
649    function MyInstanceOf(left, right) {
650        let proto = Object.getPrototypeOf(left);
651        let prototype = right.prototype;
652        while (true) {
653            if (!proto) return false;
654            if (proto === prototype) {
655                return true;
656            }
657            proto = Object.getPrototypeOf(proto)
658        }
659    }
660
661    class Person {
662    }
663
664    class Student extends Person{
665    }
666
667    let p1 = new Person();
668    let stu1 = new Student();
669    assert_equal(p1 instanceof Person,true);
670    assert_equal(MyInstanceOf(p1, Person),true);
671    assert_equal(stu1 instanceof Person,true);
672    assert_equal(MyInstanceOf(stu1, Person),true);
673    assert_equal(stu1 instanceof Student,true);
674    assert_equal(MyInstanceOf(stu1, Student),true);
675    assert_equal(p1 instanceof Student,false);
676    assert_equal(MyInstanceOf(p1, Student),false);
677}
678
679/**************HandleThrowUndefinedifholePrefV8V8****************/
680{
681    var array = [11, 8, 19];
682
683    function distinct(arr) {
684        const obj = {}
685        const result = arr.reduce((pre, cur) => {
686        if (!obj[cur.stuId]) {
687            obj[cur.stuId] = true;
688            return [...pre, cur];
689        }
690        return pre;
691    }, [])
692        assert_equal(result[0],11);
693        return result;
694    }
695    distinct(array);
696}
697
698/**************HandleThrowIfnotobjectPrefV8****************/
699{
700    var array = [168, 168, 19];
701
702    function process(arr) {
703        const cache = [];
704        for (const t of arr) {
705            if (cache.find(c => c.maxDeptCode === t.maxDeptCode && c.minDeptCode === t.minDeptCode)) {
706                continue;
707            }
708            cache.push(t);
709        }
710
711        return cache;
712    }
713    assert_equal(process(array)[0],168);
714}
715
716/**************HandleCreateemptyobject****************/
717{
718    let str = 'baobfabobodabfodao';
719    let num = str.split("").reduce((pre, cur) => {
720        if (cur in pre) {
721            pre[cur]++;
722        } else {
723            pre[cur] = 1;
724        }
725        return pre;
726    }, {})
727}
728
729/**************HandleCreateemptyarrayImm8****************/
730{
731    let array1 = [
732        { id: "50", active: "a", value: 12 },
733        { id: "51", active: "a", value: 15 }
734    ];
735    let array2 = [
736        { id: "50", active: "a", value: 10 },
737        { id: "51", active: "a", value: 11 },
738        { id: "52", active: "a", value: 13 }
739    ];
740
741    let arr = [];
742    array1.map(id =>
743        arr.push({
744            id: id.id,
745            newValue: array2.find(o => o.id === id.id).value + 2
746        })
747    );
748    let expectVar4 = "2 "+JSON.stringify(arr);
749    assert_equal(expectVar4, "2 [{\"id\":\"50\",\"newValue\":12},{\"id\":\"51\",\"newValue\":13}]");
750}
751
752/**************HandleGetnextpropnameV8****************/
753{
754    let obj1 = {
755        name: "bob",
756        age: 18,
757        sex: "man",
758      }
759    let obj2 = {}
760
761    for (let key in obj1) {
762      obj2[key] = obj1[key];
763    }
764    obj1.name = "Tom"
765    assert_equal(obj1.name,"Tom");
766}
767
768/**************HandleGetunmappedargs****************/
769{
770    function abs() {
771        if (arguments.length === 0) {
772            return 0;
773        }
774        var x = arguments[0];
775        return x >= 0 ? x : -x;
776    }
777
778    assert_equal(abs(),0);
779    assert_equal(abs(10),10);
780    assert_equal(abs(-9),9);
781}
782
783/**************HandleCopyrestargsImm8****************/
784{
785    function add(...theArgs) {
786        theArgs.push(31);
787        var result = 0;
788        for (let i = 0; i < theArgs.length; i++) {
789            result = result + theArgs[i];
790        }
791        var lastItem = theArgs.pop();
792        assert_equal(lastItem,31);
793        return result;
794    }
795
796    add();
797}
798
799/**************HandleStarrayspreadV8V8****************/
800{
801    class Parent {
802        static myMethod(msg) {
803            let expectVar5 = "static 1"
804            assert_equal(expectVar5,'static '+ msg);
805        }
806        myMethod(msg) {
807            let expectVar5 = "instance 2"
808            assert_equal(expectVar5,'instance '+ msg);
809        }
810    }
811
812    class Child extends Parent {
813        static myMethod(msg) {
814            super.myMethod(msg);
815        }
816        myMethod(msg) {
817            super.myMethod(msg);
818        }
819    }
820
821    Child.myMethod(1);
822    var child = new Child();
823    child.myMethod(2);
824}
825
826/**************HandleSupercallspreadImm8V8****************/
827{
828    class Demo {
829        constructor(x) {
830          this.x = x;
831        }
832   }
833
834   class Demo2 extends Demo{}
835
836   let d = new Demo2('hello');
837   assert_equal(d.x,"hello");
838}
839
840/**************HandleDeprecatedLdsuperbynamePrefId32V8****************/
841{
842    class Demo {
843        constructor(x,y) {
844            this.x = x;
845            this.y = y;
846        }
847        customSplit(){
848            return [...this.y]
849        }
850    }
851
852    class Demo2 extends Demo {
853        constructor(x, y) {
854            super(x, y);
855        }
856        customSplit(){
857            return [...this.x]
858        }
859        task1(){
860            return super.customSplit();
861        }
862        task2(){
863            return this.customSplit();
864        }
865    }
866
867    let d = new Demo2('hello','world');
868    assert_equal(d.task1().toString(),"w,o,r,l,d");
869    assert_equal(d.task2().toString(),"h,e,l,l,o");
870}
871
872/**************HandleCreateregexpwithliteralImm8Id16Imm8****************/
873{
874    function filterParams(obj) {
875        let _newPar = {};
876        for (let key in obj) {
877            if ((obj[key] === 0 || obj[key]) && obj[key].toString().replace(/(^\s*)|(\s*$)/g, '') !== '') {
878                _newPar[key] = obj[key];
879            }
880        }
881        return _newPar;
882    }
883  var func = filterParams({a:"", b:null, c:"010", d:123});
884  assert_equal(func.toString(),"[object Object]");
885}
886
887/**************HandleTryldglobalbynameImm8Id16****************/
888{
889    function randomNumber(n1, n2) {
890        if (arguments.length === 2) {
891            return Math.round(n1 + Math.random() * (n2 - n1));
892        } else if (arguments.length === 1) {
893            return Math.round(Math.random() * n1)
894        } else {
895            return Math.round(Math.random() * 255)
896        }
897    }
898
899    var func = randomNumber(5, 10);
900    let expectVar6 = "succ";
901    assert_equal(expectVar6,"succ");
902}
903
904/**************HandleLdaStrId16****************/
905{
906    let promise = new Promise((resolve, reject) => {
907        let expectVar7 = "Promise";
908        assert_equal(expectVar7,'Promise');
909        resolve();
910    });
911    promise.then(function() {
912    });
913}
914
915/**************HandleDeprecatedCreatearraywithbufferPrefImm16****************/
916{
917    function Change() {
918        var newArr = [];
919        for (var i = arguments.length - 1; i >= 0; i--) {
920            newArr[newArr.length] = arguments[i]
921        }
922        return newArr;
923    }
924
925    Change(1, 2345, 6, 8, 89, 5, 9);
926    var arr = [1, 2345, 6, 8, 89, 5, 9];
927    assert_equal(arr.reverse().toString(),"9,5,89,8,6,2345,1");
928}
929
930/**************HandleDeprecatedNegPrefV8****************/
931{
932    var arr = ['red', 'blue', 'red', 'green', 'pink', 'red', 'red'];
933    var index = arr.indexOf('red');
934
935    var number = 0;
936    var indexArray = [];
937    while (index != -1) {
938        indexArray.push(index);
939        var index = arr.indexOf('red', index + 1);
940        number++;
941    }
942    assert_equal(JSON.stringify(indexArray),JSON.stringify([0, 2, 5, 6]) );
943    assert_equal(number, 4);
944}
945
946/**************HandleJeqzImm8****************/
947{
948    var str5 = 'abaaudffgggghhhhjkkkgfddduuuuuu23444343434';
949        do {
950            var index = str5.indexOf('s');
951            str5 = str5.replace('s', 'u');
952        } while (index !== -1)
953
954    assert_equal(str5,"abaaudffgggghhhhjkkkgfddduuuuuu23444343434");
955}
956
957/**************HandleStobjbyvalueImm8V8V8****************/
958{
959    var str = "abcoefoxyozzopp";
960    var o = {};
961    for (var i = 0; i < str.length; i++) {
962        var chars = str.charAt(i);
963        if (o[chars]) {
964            o[chars]++;
965        } else {
966            o[chars] = 1;
967        }
968    }
969    var assertO = {
970    	"a": 1,
971    	"b": 1,
972    	"c": 1,
973    	"o": 4,
974    	"e": 1,
975    	"f": 1,
976    	"x": 1,
977    	"y": 1,
978    	"z": 2,
979    	"p": 2
980        }
981    assert_equal(JSON.stringify(o),JSON.stringify(assertO));
982}
983
984/**************HandleNoteqImm8V8****************/
985{
986    var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
987    var newArr = [];
988    for (var i = 0; i < arr.length; i++) {
989        if (arr[i] != 0) {
990            newArr[newArr.length] = arr[i];
991        }
992    }
993    assert_equal(JSON.stringify(newArr),JSON.stringify([2,6,1,77,52,25,7]));
994}
995
996/**************HandleStricteqImm8V8****************/
997{
998    function unique(arr) {
999        var newArr = []
1000        for (var i = 0; i < arr.length; i++) {
1001          if (newArr.indexOf(arr[i]) === -1) {
1002            newArr.push(arr[i])
1003          }
1004        }
1005        return newArr;
1006    }
1007    var demo = unique(['blue', 'green', 'blue']);
1008    assert_equal(demo.toString(),"blue,green");
1009}
1010
1011/**************HandleDeprecatedCallthisrangePrefImm16V8****************/
1012{
1013
1014    function countDown(time) {
1015        var nowTime = +new Date();
1016        var inputTime = +new Date(time);
1017        var times = (inputTime - nowTime) / 1000;
1018        var d = parseInt(times / 60 / 60 / 24);
1019        d = d < 10 ? '0' + d : d;
1020        var h = parseInt((times / 60 / 60) % 24);
1021        h = h < 10 ? '0' + h : h;
1022        var m = parseInt((times / 60) % 60);
1023        m = m < 10 ? '0' + m : m;
1024        var s = parseInt(times % 60);
1025        s = s < 10 ? '0' + s : s;
1026        return d + '天' + h + '时' + m + '分' + s + '秒';
1027    }
1028    (countDown('2022-10-10 18:00:00'));
1029    var date = new Date();
1030    var date1 = +new Date();
1031    assert_equal("blue","blue");
1032}
1033
1034/**************HandleStownbyindexImm8V8Imm16****************/
1035{
1036    function doMath(data) {
1037        let min = data[0];
1038        let max = data[0];
1039        let sum = 0;
1040        data.sort(function(a, b) {
1041                return a - b;
1042        })
1043        min = data[0];
1044        max = data[data.length - 1];
1045        for (let i = 0; i < data.length; i++) {
1046            sum += data[i];
1047        }
1048        return [min, max, sum];
1049    }
1050    assert_equal(JSON.stringify(doMath([23, 54, 34, 2, 7, 8, 1, 77, 43])),JSON.stringify([1,77,249]));
1051}
1052
1053/**************HandleWideNewobjrangePrefImm16V8****************/
1054{
1055    function Person(name, age) {
1056        this.name = name;
1057        this.age = age;
1058        this.say = function () {
1059            return "name : " + this.name + " age: " + this.age;
1060        };
1061    }
1062
1063    var o = new Object();
1064    Person.call(o, "zhangsan", 20);
1065    assert_equal(o.say(),"name : zhangsan age: 20");
1066}
1067
1068/**************HandleWideLdobjbyindexPrefImm32****************/
1069{
1070    function maxValue() {
1071        var max = arguments[0];
1072        for (var i = 0; i < arguments.length; i++) {
1073           if (max < arguments[i]) {
1074            max = arguments[i];
1075           }
1076        }
1077        return max;
1078    }
1079    assert_equal(maxValue(2, 4, 5, 9),9);
1080    assert_equal(maxValue(12, 4, 9),12);
1081}
1082
1083/**************HandleDeprecatedLdobjbynamePrefId32V8****************/
1084{
1085    var obj = {};
1086    Object.defineProperty(obj, "x", {
1087    value : 1,
1088    writable : true,
1089    enumerable : true,
1090    configurable : true
1091    });
1092    assert_equal(obj.x,1);
1093}
1094
1095/*
1096*    PtrAdd(); IntPtrSize();
1097*    DispatchWithId();
1098*/
1099                      /**************HandleThrow****************/
1100{
1101    var fun = function() {
1102        throw "boom";
1103    }
1104    try {
1105        var a = fun();
1106    } catch (e) {}
1107}
1108
1109test_end();