Чи є причина, що тести не записуються в рядку з кодом, який вони перевіряють?

Нещодавно я читав трохи про грамотне програмування , і це задумало мене ... Добре написані тести, особливо специфікації в стилі BDD, можуть зробити кращу роботу при поясненні того, що робить код, ніж проза, і мають велику перевагу перевірка власної точності.

Я ніколи не бачив тестів, написаних на зразок коду, який вони перевіряють. Це лише тому, що мови, як правило, не спрощують розділяти додаток і тестовий код, коли вони написані в одному вихідному файлі (а це ніхто не спрощує), або є більш принципова причина, що люди відокремлюють тестовий код від коду програми?

Єдиною перевагою, яку я можу придумати для вбудованих тестів, буде зменшення кількості записуваних файлів. З сучасними ІДЕ насправді це не так вже й багато.

Однак існує ряд очевидних недоліків для вбудованого тестування:

• Це порушує розділення проблем . Це може бути дискусійним, але для мене тестування функціональності є іншим обов'язком, ніж його реалізація.
• Вам потрібно буде ввести нові мовні функції, щоб розрізняти тести / реалізацію, або ви ризикуєте розмити лінію між ними.
• З більшими вихідними файлами важче працювати: важче читати, важче зрозуміти, вам більше шансів зіткнутися з конфліктами управління джерелами.
• Я думаю, що було б важче надягнути шапку "тестера", так би мовити. Якщо ви переглядаєте деталі реалізації, вам буде більше спокуси пропустити впровадження певних тестів.

Я можу подумати про деякі:

• Читабельність. Інтерперсинг "реального" коду та тестів ускладнить читання реального коду.

• Код роздуття. Змішування "реального" коду та тестового коду в одних і тих же файлах / класах / що завгодно може призвести до більшого розміру файлів і т. Д. Це особливо важливо для мов з пізнім прив'язкою.

• Можливо, ви не хочете, щоб ваші клієнти / клієнти бачили ваш тестовий код. (Мені це не подобається ... але якщо ви працюєте над проектом із закритим джерелом, тестовий код навряд чи допоможе замовнику.)

Зараз можливі шляхи вирішення кожного з цих питань. Але ІМО, простіше не їхати туди в першу чергу.

Варто зауважити, що в перші дні програмісти Java раніше робили подібні речі; наприклад, включення main(...)методу в клас для полегшення тестування. Ця ідея майже повністю зникла. Це галузева практика застосовувати тести окремо, використовуючи якусь тестову рамку.

Варто також зауважити, що грамотне програмування (за задумом Кнута) ніколи не натрапляло на галузь інженерії програмного забезпечення.

Власне, ви можете подумати про дизайн за контрактом як про це. Проблема полягає в тому, що більшість мов програмування не дозволяють писати такий код :( Тестувати передумови вручну дуже просто, але умови публікації - справжнє завдання без зміни способу написання коду (величезний негативний ІМО).

Майкл Пірс має презентацію про це, і це один із багатьох способів, про які він згадує, як можна покращити якість коду.

З багатьох тих самих причин, що ви намагаєтесь уникнути жорсткого зв’язку між класами у своєму коді, також непогано уникати непотрібної зв'язку між тестами та кодом.

Створення: Тести та код можуть бути написані різними людьми.

Контроль: Якщо для визначення вимог використовуються тести, ви, звичайно, хочете, щоб на них поширювалися різні правила щодо того, хто може їх змінити і коли, ніж власне код.

Повторність використання: Якщо ви поставите тести вбудовані, ви не можете використовувати їх з іншим фрагментом коду.

Уявіть, що у вас є шматок коду, який виконує роботу правильно, але залишає бажати кращого з точки зору продуктивності, ремонтопридатності, будь-якого іншого. Ви вирішили замінити цей код новим та вдосконаленим кодом. Використання того ж набору тестів може допомогти вам переконатися, що новий код дає ті самі результати, що і старий код.

Вибірність: Тримання тестів окремо від коду полегшує вибір тестів, які потрібно запустити.

Наприклад, у вас може бути невеликий набір тестів, які стосуються лише коду, над яким ви зараз працюєте, і більший набір, який тестує весь проект.

Ось кілька додаткових причин, про які я можу подумати:

• наявність тестів в окремій бібліотеці полегшує зв’язок лише цієї бібліотеки з тестовою рамкою, а не з виробничим кодом (цього міг би уникнути деякий препроцесор, але навіщо будувати таке, коли простіше рішення писати тести в окреме місце)

• тести функції, класу, бібліотеки, як правило, записуються з точки зору "користувачів" (користувач цієї функції / класу / бібліотеки). Такий "використання коду", як правило, записується в окремий файл або бібліотеку, і тест може бути чіткішим або "більш реалістичним", якщо він імітує цю ситуацію.

Якщо випробування були вбудованими, необхідно буде видалити код, необхідний для тестування, коли ви доставляєте товар своєму замовнику. Так додаткове місце , де ви зберігаєте ваші тести просто розділяє між кодом вам потрібно , і кодом вашого клієнта потребує.

Ця ідея просто є методом "Self_Test" в контексті об'єктно-орієнтованого дизайну. Якщо використовується компільована об'єктна мова на зразок Ada, весь код самотестування буде позначений компілятором як невикористаний (ніколи не викликаний) під час виробничої компіляції, і тому все це буде оптимізовано - жодне з них не з’явиться в отриманий виконуваний файл.

Використання методу "Self_Test" - надзвичайно гарна ідея, і якби програмісти справді переймалися якістю, вони все б робили. Одне важливе питання полягає в тому, що метод "Self_Test" повинен мати сувору дисципліну, оскільки він не може отримати доступ до будь-якої деталі реалізації та замість цього повинен покладатися лише на всі інші опубліковані методи в специфікації об'єкта. Очевидно, якщо самовипробування не вдасться, реалізацію потрібно буде змінити. Самовипробування повинно ретельно перевіряти всі опубліковані властивості методів об'єкта, але ніколи не покладатися жодним чином на якісь деталі будь-якої конкретної реалізації.

Об'єктно-орієнтовані мови часто надають саме такий тип дисципліни стосовно методів, що знаходяться поза тестованим об'єктом (вони застосовують специфікацію об'єкта, запобігаючи будь-якому доступу до деталей його реалізації та підвищуючи помилку компіляції, якщо будь-яка така спроба виявлена ). Але внутрішні методи об'єкта отримують повний доступ до кожної деталі реалізації. Таким чином, метод самотестування знаходиться в унікальній ситуації: він повинен бути внутрішнім методом через свою природу (самовипробування, очевидно, є методом тестуваного об'єкта), але він повинен отримати всю дисципліну компілятора зовнішнього методу ( він повинен бути незалежним від деталей реалізації об'єкта). Мало, якщо якісь мови програмування надають можливість дисциплінувати предмет " s внутрішній метод, як ніби це зовнішній метод. Отже, це важливе питання дизайну мови програмування.

За відсутності належної підтримки мови програмування найкращий спосіб зробити це - створити супутній об’єкт. Іншими словами, для кожного об'єкта, який ви кодуєте (назвемо його "Big_Object"), ви також створюєте другий супутній об'єкт, ім'я якого складається зі стандартного суфікса, об'єднаного з іменем "реального" об'єкта (у цьому випадку "Big_Object_Self_Test" "), специфікація якого складається з єдиного методу (" Big_Object_Self_Test.Self_Test (This_Big_Object: Big_Object) повертає булевий; "). Потім об'єкт-супутник буде залежати від специфікації основного об'єкта, і компілятор буде повністю виконувати всю дисципліну цієї специфікації проти реалізації об'єкта-супутника.

Це є відповіддю на велику кількість коментарів, що свідчать про те, що вбудовані тести не робляться, оскільки важко неможливо видалити тестовий код із версій версій. Це неправда. Практично всі компілятори та асемблери підтримують це вже зі складеними мовами, такими як C, C ++, C #, це робиться з тими, що називаються директивами компілятора.

У випадку c # (я також вважаю, що і c ++, синтаксис може дещо відрізнятися залежно від того, який компілятор ви використовуєте) ось так ви можете це зробити.

#define DEBUG //  = true if c++ code
#define TEST /* can also be defined in the make file for c++ or project file for c# and applies to all associated .cs/.cpp files */

//somewhere in your code
#if DEBUG
// debug only code
#elif TEST
// test only code
#endif

Оскільки для цього використовуються директиви компілятора, код не буде існувати у виконуваних файлах, які створюються, якщо прапорці не встановлені. Це також те, як ви змушуєте "писати один раз, компілювати двічі" програми для декількох платформ / обладнання.

Ми використовуємо вбудовані тести з нашим кодом Perl. Існує модуль Test :: Inline , який генерує тестові файли з вбудованого коду.

Я не особливо добре впорядковую свої тести, і вважаю, що їх легше і швидше підтримувати при накресленні.

Відповідаючи на пару занепокоєнь:

• Вбудовані тести записуються у розділи POD, тому вони не є частиною фактичного коду. Інтерпретатор їх ігнорує, тому немає коду.
• Ми використовуємо складку Vim для приховування тестових секцій. Єдине, що ви бачите - це один рядок над кожним методом, який тестується +-- 33 lines: #test----. Коли ви хочете працювати з тестом, ви просто розширите його.
• Модуль Test :: Inline "збирає" тести до звичайних TAP-сумісних файлів, щоб вони могли співіснувати з традиційними тестами.

Довідково:

• ПОД
• ТАП

Erlang 2 фактично підтримує вбудовані тести. Бугельне вираження в коді, який не використовується (наприклад, присвоєний змінній або переданий), автоматично трактується як тест і оцінюється компілятором; якщо вираз хибний, код не компілюється.

Іншою причиною розділення тестів є те, що ви часто використовуєте додаткові або навіть інші бібліотеки для тестування, ніж для реальної реалізації. Якщо ви змішуєте тести та реалізацію, компілятор не може потрапити на користувальницьке використання тестових бібліотек під час реалізації.

Крім того, тести, як правило, мають більше кодових рядків, ніж тестові частини, які вони тестують, тому у вас виникнуть проблеми з пошуком реалізації між усіма тестами. :-)

Це неправда. Набагато краще розмістити свої одиничні тести поруч із виробничим кодом, коли виробничий код, особливо коли виробнича процедура є чистою.

Наприклад, якщо ви розробляєте під .NET, наприклад, ви можете помістити свій тестовий код у виробничу збірку, а потім скористатися Scalpel, щоб видалити їх перед відправкою.