Windows 7-ის დამალული პროცესები. როგორ მოვძებნოთ და ამოიღოთ ვირუსის პროცესი? შესაძლებელია თუ არა „მარცხენა“ პროცესის დადგენა

და არის ოფიციალური jQuery ტესტირების ინსტრუმენტი. მაგრამ QUnit შესანიშნავია ნებისმიერი JavaScript კოდის შესამოწმებლად და შეუძლია JavaScript backend-ის ტესტირებაც კი ისეთი ძრავების გამოყენებით, როგორიცაა Rhino ან V8.

თუ არ იცნობთ "ერთეულის ტესტირების" იდეას, არ ინერვიულოთ - ამაში არაფერია რთული:

"ერთეულის ტესტირება ან ერთეულის ტესტირება (ინგლისური) ერთეულის ტესტირება) არის პროგრამირების პროცესი, რომელიც საშუალებას გაძლევთ შეამოწმოთ პროგრამის წყაროს კოდის ცალკეული მოდული სისწორისთვის. იდეა არის ტესტების დაწერა ყველა არატრივიალური ფუნქციის ან მეთოდისთვის. ეს საშუალებას გაძლევთ სწრაფად შეამოწმოთ, გამოიწვია თუ არა შემდეგი კოდის ცვლილება რეგრესია, ანუ შეცდომების გამოჩენა პროგრამის უკვე აპრობირებული ადგილებში და ასევე ხელს უწყობს ასეთი შეცდომების აღმოჩენას და აღმოფხვრას. ”

განმარტება ციტირებულია ვიკიპედიიდან. უბრალოდ გააკეთეთ ტესტები თქვენი კოდის თითოეული ფუნქციური ბლოკისთვის და თუ ყველა ტესტი გაივლის, მაშინ შეგიძლიათ დარწმუნებული იყოთ, რომ შეცდომები არ არის (ძირითადად დამოკიდებულია იმაზე, თუ რამდენად ფრთხილად არის შემუშავებული ტესტები).

რატომ უნდა შეამოწმოთ თქვენი კოდი

თუ აქამდე არასოდეს დაგიწერიათ ერთეულის ტესტები, თქვენ ალბათ უბრალოდ უმასპინძლეთ თქვენს კოდს პირდაპირ ვებ სერვერზე, გაუშვით, უყურეთ შეცდომებს და სცადეთ მათი გამოსწორება მათი აღმოჩენისთანავე. მუშაობის ეს მეთოდი ბევრ პრობლემას იწვევს.

ჯერ ერთი, ეს ძალიან დამღლელი და მოსაწყენი საქმიანობაა. ვალიდაცია რეალურად საკმაოდ რთული სამუშაოა, რადგან დარწმუნებული უნდა იყოთ, რომ ყველაფერი დაჭერილია. და ამ პროცესში არის ძალიან დიდი ალბათობა იმისა, რომ ერთი ან ორი პუნქტი შეიძლება გამოტოვოთ.

მეორეც, ყველაფერი, რაც კეთდება ასეთი ტესტირებისთვის, არ შეიძლება ხელახლა იქნას გამოყენებული. ამ მეთოდით ძალიან რთულია რეგრესიების პოვნა. რა არის რეგრესიები? წარმოიდგინეთ, რომ თქვენ დაწერეთ კოდი და შეამოწმეთ იგი, შეასწორეთ ყველა ნაპოვნი შეცდომა და განათავსეთ კოდი საიტზე. შემდეგ მომხმარებელმა გაუგზავნა გამოხმაურება ახალი შეცდომების შესახებ და ახალი ფუნქციების მოთხოვნა. თქვენ უბრუნდებით კოდს, ასწორებთ შეცდომებს და ამატებთ ახალ ფუნქციებს. ამ შემთხვევაში, შეიძლება შეიქმნას სიტუაცია, როდესაც ძველი შეცდომები კვლავ გამოჩნდება, რასაც "რეგრესია" უწოდებენ. ყველაფერი ისევ უნდა გადაამოწმო. და არის შანსი, რომ თქვენ ვერ იპოვით თქვენს ძველ შეცდომებს. ნებისმიერ შემთხვევაში, დრო დასჭირდება, სანამ გააცნობიერებთ, რომ პრობლემა გამოწვეულია "რეგრესით". ერთეულის ტესტირების გამოყენებისას თქვენ წერთ ტესტს. კოდის შეცვლის შემდეგ, თქვენ კვლავ გაფილტრავთ მას ტესტის საშუალებით. თუ რეგრესია მოხდა, მაშინ ზოგიერთი ტესტი ჩაიშლება და თქვენ შეგიძლიათ მარტივად განსაზღვროთ კოდის რომელი ნაწილი შეიცავს შეცდომას. ვინაიდან თქვენ იცით, რა შეცვალეთ, შეცდომის გამოსწორება ადვილი იქნება.

ერთეულის ტესტირების კიდევ ერთი უპირატესობა (განსაკუთრებით ვებ დეველოპმენტისთვის) არის ის, რომ ადვილია შეამოწმოთ ბრაუზერის თავსებადობა. თქვენ უბრალოდ უნდა ჩაატაროთ ტესტები სხვადასხვა ბრაუზერში. ბრაუზერში პრობლემების აღმოჩენის შემთხვევაში, შეგიძლიათ მათი გამოსწორება და ტესტის ხელახლა გაშვება. შედეგად, თქვენ დარწმუნებული იქნებით, რომ ყველა სამიზნე ბრაუზერი მხარდაჭერილია, რადგან ისინი ყველა შემოწმებულია.

როგორ დავწეროთ ერთეული ტესტები QUnit-ში

მაშ, როგორ წერთ ერთეულების ტესტებს QUnit-ში? პირველი ნაბიჯი არის ტესტირების გარემოს დაყენება:

QUnit Test Suite QUnit Test Suite

კოდი, რომელიც შემოწმდება, გადადის myProject.js ფაილში, ტესტები კი myTests.js-ში. ტესტების გასაშვებად, თქვენ უბრალოდ უნდა გახსნათ HTML ფაილი თქვენს ბრაუზერში. ახლა დროა დავწეროთ ტესტი.

ერთეულის ტესტირების სამშენებლო ბლოკი არის მტკიცება.

"მტკიცება არის გამოხატულება, რომელიც წინასწარმეტყველებს დაბრუნების შედეგს თქვენი კოდის შესრულებისას. თუ პროგნოზი არასწორია, მაშინ მტკიცებას აქვს მნიშვნელობა. ყალბი, რაც საშუალებას გვაძლევს გამოვიტანოთ დასკვნები შეცდომების არსებობის შესახებ“.

განცხადებების შესასრულებლად, ისინი უნდა განთავსდეს სატესტო ბლოკში:

// შეამოწმეთ ამ ფუნქციის ფუნქცია isEven(val) ( return val % 2 === 0; ) test("isEven()", function() (ok(isEven(0), "ნული არის ლუწი რიცხვი"); ok ( isEven(2), "Two is also"); isEven(-7), "როგორც უარყოფითი შვიდი არის კენტი რიცხვი");

აქ ჩვენ განვსაზღვრავთ ფუნქციას არის თანაბარი, რომელიც ამოწმებს რიცხვის პარიტეტს და გვინდა დავრწმუნდეთ, რომ ეს ფუნქცია არ დააბრუნებს მცდარ მნიშვნელობებს.

პირველ რიგში ვუწოდებთ ფუნქციას ტესტი (), რომელიც აშენებს სატესტო ბლოკს. პირველი პარამეტრი არის სტრიქონი, რომელიც გამოვა შედეგად. მეორე პარამეტრი არის დაბრუნების ფუნქცია, რომელიც შეიცავს ჩვენს მტკიცებას. ეს გამოძახების ფუნქცია გამოიძახება ერთხელ QUnit-ის შესრულებისას.

ჩვენ დავწერეთ ხუთი განცხადება, ყველა მათგანი ლოგიკურია. ლოგიკური განცხადება ვარაუდობს, რომ პირველ პარამეტრს აქვს მნიშვნელობა მართალია. მეორე პარამეტრი არის შეტყობინება, რომელიც ნაჩვენებია შედეგში.

ეს არის ის, რასაც ვიღებთ ტესტის გავლის შემდეგ:

ყველა ჩვენი განცხადება წარმატებით დადასტურდა, ამიტომ შეგვიძლია ვივარაუდოთ, რომ ფუნქცია isEven ()მუშაობს ისე, როგორც მოსალოდნელია.

ვნახოთ, რა მოხდება, თუ განცხადება მცდარია.

// შეამოწმეთ ამ ფუნქციის ფუნქცია isEven(val) ( return val % 2 === 0; ) test("isEven()", function() (ok(isEven(0), "ნული არის ლუწი რიცხვი"); ok ( isEven(2), "Two is also"); isEven(-7), "Like negative შვიდი არის კენტი" // შეცდომა ok(isEven(3), "Three is an ლუწი რიცხვი");

და აი რას ვიღებთ ტესტის გავლის შედეგად:

განცხადება შეიცავს შეცდომას, რომელიც ჩვენ განზრახ დავუშვით. მაგრამ თქვენს პროექტში, თუ ზოგიერთი ტესტი ჩავარდა და ყველა სხვა განცხადება სწორია, მაშინ შეცდომის პოვნა ძალიან ადვილი იქნება.

სხვა განცხადებები

ok() არ არის ერთადერთი განცხადება, რომელსაც QUnit მხარს უჭერს. არსებობს სხვა ტიპის მტკიცებები, რომლებიც გამოსაყენებელია თქვენი პროექტებისთვის ტესტების წერისას:

შედარების განცხადება

შედარების განცხადება უდრის ()ვარაუდობს, რომ პირველი პარამეტრი (რომელიც არის რეალური მნიშვნელობა) ექვივალენტურია მეორე პარამეტრის (რომელიც არის მოსალოდნელი მნიშვნელობა). ეს განცხადება ძალიან ჰგავს კარგი(), მაგრამ გამოსცემს როგორც რეალურ, ასევე მოსალოდნელ მნიშვნელობებს, რაც ბევრად აადვილებს კოდის გამართვას. Ისევე, როგორც კარგი(), უდრის ()შეუძლია მიიღოს შეტყობინება გამოსასვლელად მესამე პარამეტრად.

ასე რომ ნაცვლად

ტესტი ("მტკიცებულებები", ფუნქცია() ( ok(1 == 1, "ერთი უდრის ერთს"); ))

უნდა იქნას გამოყენებული:

ტესტი ("მტკიცებულებები", ფუნქცია() ( უდრის (1, 1, "ერთი უდრის ერთს"); ))

გაითვალისწინეთ, რომ მოსალოდნელი მნიშვნელობა იბეჭდება სტრიქონის ბოლოს.

და თუ მნიშვნელობები არ არის თანაბარი:

ტესტი ("მტკიცებულებები", ფუნქცია() ( უდრის (2, 1, "ერთი უდრის ერთს"); ))

ეს ჩანაწერი იძლევა მეტ ინფორმაციას.

შედარების მტკიცება იყენებს "==" ოპერატორს პარამეტრების შესამოწმებლად, ამიტომ მას არ შეუძლია მუშაობა მასივებთან ან ობიექტებთან:

Test("ტესტი", ფუნქცია() (ტოლია ((), (), "შეცდომა, ეს სხვადასხვა ობიექტებია"); ტოლია ((a: 1), (a: 1) , "შეცდომა"); ტოლია(, , "error, ეს არის სხვადასხვა მასივები");

ასეთი შემთხვევებისთვის QUnit-ს აქვს პირადობის მტკიცება.

პირადობის მტკიცება

პირადობის მტკიცება იგივე ()იყენებს იგივე პარამეტრებს, როგორც უდრის (), მაგრამ ის მუშაობს არა მხოლოდ პრიმიტიულ ტიპებთან, არამედ მასივებთან და ობიექტებთან. წინა მაგალითის განცხადებები გაივლის გამოცდას, თუ შეიცვალა პირადობის განცხადებებიდან:

ტესტი("ტესტი", ფუნქცია() (იგივე((), (), "გადის, ობიექტებს აქვთ იგივე შინაარსი"); same((a: 1), (a: 1) , "გადის"); იგივე( , , "გადის, მასივებს აქვთ იგივე შინაარსი");

გთხოვთ გაითვალისწინოთ, რომ იგივე ()იყენებს '===' ოპერატორს შედარებისთვის, ამიტომ მოსახერხებელია მისი გამოყენება სპეციალური მნიშვნელობების შესადარებლად:

ტესტი ("ტესტი", ფუნქცია() (ტოლია (0, მცდარი, "ჭეშმარიტი"); იგივე (0, მცდარი, "მცდარი"); ტოლია (null, განუსაზღვრელი, "true"); იგივე (null, განუსაზღვრელი, " ყალბი");))

განცხადების სტრუქტურა

ყველა მტკიცების ერთ ტესტში მოთავსება ძალიან ცუდი იდეაა. ასეთი ტესტის შენარჩუნება რთული იქნება და მისი შესრულების შედეგების შეფასებაში შეიძლება დაიბნეთ. ამიტომ, თქვენ უნდა მოაწყოთ ტესტი, განცხადებების განთავსებით ცალკეულ ბლოკებში, რომელთაგან თითოეული მიმართული იქნება ფუნქციების კონკრეტულ ჯგუფზე.

შეგიძლიათ ინდივიდუალური მოდულების ორგანიზება ფუნქციის ზარის გამოყენებით მოდული:

მოდული ("მოდული A"); test("ტესტი", ფუნქცია() ()); test("სხვა ტესტი", ფუნქცია() ()); მოდული ("მოდული B"); test("ტესტი", ფუნქცია() ()); test("სხვა ტესტი", ფუნქცია() ());

წინა მაგალითში ყველა განცხადება გამოიძახეს სინქრონულად, ანუ ისინი შესრულდა ერთმანეთის მიყოლებით. რეალურ სამყაროში ბევრი ასინქრონული ფუნქციაა, როგორიცაა AJAX მოთხოვნები ან ფუნქციები setTimeout ()და setInterval(). როგორ ვამოწმებთ ამ ტიპის ფუნქციონირებას? QUnit-ს აქვს სპეციალური ტესტის ტიპი, სახელწოდებით "ასინქრონული ტესტი", რომელიც განკუთვნილია ასინქრონული ტესტირებისთვის:

პირველ რიგში, შევეცადოთ დავწეროთ ტესტი ჩვეულებრივი გზით:

ტესტი ("ასინქრონული ტესტი", ფუნქცია() ( setTimeout(function() (ok(true); ), 100) ))

როგორც ჩანს, ტესტში არანაირი მტკიცება არ არის. იმის გამო, რომ განცხადება შესრულდა სინქრონულად, მაგრამ ფუნქციის გამოძახების დროისთვის ტესტი უკვე დასრულებული იყო.

ჩვენი მაგალითის შესამოწმებლად სწორი გზაა:

Test("ასინქრონული ტესტი", ფუნქცია() ( // ჩადეთ ტესტი პაუზის რეჟიმში stop(); setTimeout(function() (ok(true); // მტკიცების გამოძახების შემდეგ // გააგრძელეთ ტესტის დაწყება(); ) 100)))

ჩვენ გამოვიყენეთ ფუნქცია გაჩერება ()ტესტის შესაჩერებლად და მტკიცების შესრულების შემდეგ კვლავ ჩაატარეთ ტესტი ფუნქციის გამოყენებით დაწყება ().

ფუნქციის გამოძახება გაჩერება ()ფუნქციის გამოძახებისთანავე ტესტი ()ძალიან გავრცელებული პრაქტიკაა. ამიტომ QUnit-ს აქვს სპეციალური აბრევიატურა: asyncTest (). წინა მაგალითი შეიძლება გადაიწეროს შემდეგნაირად:

AsyncTest("ასინქრონული ტესტი", ფუნქცია() ( // ტესტი ავტომატურად გადადის "პაუზის" რეჟიმში setTimeout(function() ( ok(true); // მტკიცების გამოძახების შემდეგ // გააგრძელეთ ტესტის დაწყება(); ) , 100)))

არის ერთი წერტილი, რომელზეც ღირს დაფიქრება: ფუნქცია setTimeout ()ყოველთვის იძახებს თავის გამოძახების ფუნქციას და სხვა ფუნქციის ტესტირებისას (მაგალითად, AJAX ზარი). როგორ შეგიძლიათ დარწმუნებული იყოთ, რომ გამოძახების ფუნქცია გამოიძახება? თუ დაბრუნების ფუნქცია არ არის გამოძახებული, ფუნქცია დაწყება ()ასევე გამოუძახებელი დარჩება და მთელი ტესტი გაიყინება:

ტესტის ორგანიზება შეგიძლიათ შემდეგნაირად:

// მორგებული ფუნქციის ფუნქცია ajax(successCallback) ($.ajax(( url: "server.php", success: successCallback )); ) test ("ასინქრონული ტესტი", ფუნქცია() ( // შეაჩერე ტესტი და // ანგარიში შეცდომა, თუ start() ფუნქცია არ გამოიძახება 1 წამის გაჩერების შემდეგ (1000 ajax(function() ( // ...ასინქრონული განაცხადი start();

ფუნქციონირებს გაჩერება ()დროის ამოწურვის მნიშვნელობა გადაეცემა. ახლა QUnit-ს ეუბნებიან: „თუ ფუნქცია დაწყება ()არ იქნება გამოძახებული ვადის ამოწურვის შემდეგ, ეს ტესტი ჩავარდნილად უნდა ჩაითვალოს“. ახლა მთელი ტესტი არ გაიყინება და გაფრთხილება გაიცემა, თუ რამე არასწორედ მოხდება.

ახლა განვიხილოთ მრავალი ასინქრონული ფუნქციის შემთხვევა. სად განთავსდება ფუნქცია დაწყება ()? თქვენ უნდა მოათავსოთ ის ფუნქციაში setTimeout ():

// მორგებული ფუნქციის ფუნქცია ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Async test", function() ( // Stop the test stop(); ajax (function() ( // ...ასინქრონული განცხადება )) ajax(function() ( // ...ასინქრონული განცხადება )) setTimeout(function() ( start(); ), 2000 ));

დროის ამოწურვის მნიშვნელობა უნდა იყოს საკმარისი იმისათვის, რომ ორივე გამოძახება დასრულდეს ტესტის გაგრძელებამდე. თუ რომელიმე ფუნქცია არ არის გამოძახებული, როგორ განვსაზღვროთ რომელი? ამისთვის არის ფუნქცია ველით():

// მორგებული ფუნქციის ფუნქცია ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test ("ასინქრონული ტესტი", ფუნქცია() ( // Stop the test stop(); / / უთხარით QUnit-ს, რომ ჩვენ ველით, რომ შესრულდება სამი წინადადება expect(3) ajax(function() (ok(true); )) ajax(function() (ok(true); ok(true); ფუნქცია ( ) ( დაწყება (); ), 2000 ))

ჩვენ გადავდივართ ფუნქციაზე ველით()განცხადებების რაოდენობა, რომლის შესრულებაც იგეგმება. თუ რომელიმე განცხადება ვერ მოხერხდა, თქვენ მიიღებთ შეტყობინებას, რომელიც მიუთითებს იმაზე, რომ რაღაც ისე არ მიდის, როგორც დაგეგმილი იყო.

არის მოკლე ჩანაწერი, რომ გამოიყენოთ ველით(): მეორე პარამეტრად უნდა ჩაწეროთ დაგეგმილი განცხადებების რაოდენობა ტესტი ()ან asyncTest ():

// მორგებული ფუნქციის ფუნქცია ajax(successCallback) ($.ajax(( url: "server.php", success: successCallback )); ) // უთხარით QUnit-ს, რომ ჩვენ ველით, რომ შესრულდება 3 განცხადება ტესტი ("ასინქრონული ტესტი", 3 , ფუნქცია() ( // შეაჩერე ტესტის გაჩერება(); ajax(function() ( ok(true); )) ajax(function() (ok(true); ok(true); )) setTimeout(function() (დაწყება (); 2000);

დასკვნა

ამ სახელმძღვანელოში ჩვენ მოგაწოდეთ ყველაფერი, რაც გჭირდებათ QUnit-ის დასაწყებად. ერთეულის ტესტირება შესანიშნავი მეთოდია კოდის შესამოწმებლად მის გამოყენებამდე. თუ აქამდე არასდროს გამოგიყენებიათ ტესტები, ახლა დაწყების დროა.